Programmazione orientata agli oggetti: differenze tra le versioni

Versione delle 23:36, 13 feb 2023

Versione delle 10:13, 20 mar 2023

Riga 1:

{{F|programmazione|febbraio 2013}}

In [[informatica]], la '''programmazione orientata agli oggetti''' (in [[Lingua inglese|inglese]] ''object-oriented programming'', in [[acronimo]] '''OOP'''), a volte chiamata semplicemente '''programmazione ad oggetti''', è un [[paradigma di programmazione]] che permette di definire [[Oggetto (informatica)|oggetti]] [[software]] in grado di interagire gli uni con gli altri attraverso lo scambio di messaggi. È particolarmente adatta nei contesti in cui si possono definire delle relazioni di interdipendenza tra i concetti da modellare (contenimento, uso, specializzazione). Un ambito che più di altri riesce a sfruttare i vantaggi della programmazione a oggetti è quello delle [[Interfaccia grafica|interfacce grafiche]].

Tra gli altri vantaggi della programmazione orientata agli oggetti:

* essa fornisce un supporto naturale alla modellazione [[software]] degli oggetti del mondo reale o del modello astratto da riprodurre;

* permette una più facile gestione e manutenzione di progetti di grandi dimensioni;

* l'organizzazione del [[codice sorgente|codice]] sotto forma di [[Classe (informatica)|classi]] favorisce la [[modularità]] e il [[riuso di codice]].

== Storia ==

Il concetto di ''classe'' può essere considerato un'estensione di quello di [[tipo di dato astratto]], sviluppatosi inizialmente all'interno del paradigma della [[programmazione procedurale]], che prevede la definizione da parte del programmatore di [[tipi di dato]] con cui si può interagire solo attraverso una [[interfaccia (informatica)|interfaccia]] ben definita, nascondendo all'utilizzatore i dettagli dell'implementazione.<br />

I costrutti sintattici che permettono di definire una classe, nei linguaggi a oggetti, possono essere visti come un supporto strutturato per realizzare i dati astratti.

Il primo linguaggio di programmazione orientato agli oggetti fu il [[Simula]] ([[1967]]), seguito negli [[Anni 1970|anni settanta]] da [[Smalltalk]] e da varie estensioni del [[Lisp]]. Negli [[Anni 1980|anni ottanta]] sono state create estensioni orientate ad oggetti del [[C (linguaggio)|linguaggio C]] ([[C++]], [[Objective-C]] e altri), e di altri linguaggi ([[Object Pascal]]). Negli [[Anni 1990|anni novanta]] quello ad oggetti è diventato il paradigma dominante, per cui gran parte dei linguaggi di programmazione erano o nativamente orientati agli oggetti o avevano una estensione in tal senso.

Linguaggi che supportano solo il paradigma di programmazione orientata agli oggetti sono Smalltalk ed [[Eiffel (linguaggio)|Eiffel]].

Più spesso si incontra una realizzazione non esclusiva del paradigma di programmazione orientata agli oggetti, come in [[C++]], [[Java (linguaggio di programmazione)|Java]], [[Delphi]], [[Python]], [[C sharp|C#]], [[Visual Basic .NET]], [[Perl]], [[PHP]] (a partire dalla versione 4).

== Descrizione ==

La programmazione ad oggetti prevede di raggruppare in alcune parti circoscritte del [[codice sorgente]], chiamate ''[[#Classi|classi]]'', la dichiarazione delle [[struttura dati|strutture dati]] e delle [[funzione (informatica)|procedure]] che operano su di esse. Le classi, quindi, costituiscono dei modelli astratti, che a [[Run-time|tempo di esecuzione]] vengono invocate per istanziare o creare [[#Oggetti|oggetti]] software relativi alla classe invocata. Questi ultimi sono dotati di ''attributi'' (dati) e ''[[Metodo (programmazione)|metodi]]'' (procedure) secondo quanto definito/dichiarato dalle rispettive classi.

La parte del programma che fa uso di un oggetto si chiama ''client''.

Un linguaggio di programmazione è definito ''ad oggetti'' quando permette di implementare tre meccanismi usando la sintassi nativa del linguaggio<ref>Questi meccanismi possono essere simulati anche nei linguaggi che non sono considerati ad oggetti, a patto di adottare altri costrutti e di rispettare determinate convenzioni durante la scrittura del testo del programma.</ref>:

* [[#Incapsulamento|incapsulamento]];

* [[#Ereditarietà|ereditarietà]];

* [[#Polimorfismo|polimorfismo]].

L<nowiki>'</nowiki>'''incapsulamento''' consiste nella separazione della cosiddetta [[Interfaccia (informatica)#Interfaccia nella programmazione orientata agli oggetti|interfaccia]] di una classe dalla corrispondente implementazione, in modo che i client di un oggetto di quella classe possano utilizzare la prima, ma non la seconda.

L<nowiki>'</nowiki>'''ereditarietà''' permette essenzialmente di definire delle classi a partire da altre già definite.

Il '''polimorfismo''' permette di scrivere un client che può servirsi di oggetti di classi diverse, ma dotati di una stessa [[Interfaccia (informatica)#Interfaccia nella programmazione orientata agli oggetti|interfaccia]] comune; nel tempo di esecuzione tale client potrà attivare comportamenti diversi senza conoscere a priori il tipo specifico dell'oggetto che gli viene dato in ingresso.

=== Classi ===

{{vedi anche|Classe (informatica)}}

Le classi definiscono dei [[tipi di dato]] e permettono la creazione degli oggetti secondo le caratteristiche definite nella classe stessa. Grazie alle relazioni di [[ereditarietà (informatica)|ereditarietà]], è possibile creare nuove classi a partire da quelle esistenti, estendendole con caratteristiche aggiuntive.

La classe è composta da:

* ''attributi'' (analoghi ai membri di un [[Struttura dati#Record o struttura|record]]), ossia [[variabile (informatica)|variabili]] e/o [[costante (informatica)|costanti]] che definiscono le caratteristiche o proprietà degli oggetti instanziabili invocando la classe; i valori inizializzati degli attributi sono ottenuti attraverso il cosiddetto [[Costruttore (informatica)|costruttore]];

* ''metodi'', ossia [[funzione (informatica)|procedure]] che operano sugli attributi.

Un paragone (impreciso) con la [[matematica]] è il seguente: si può pensare che una classe definisca un [[insieme]] in modo intensivo, ovvero indicandone le caratteristiche invece che elencandone gli elementi, e che gli oggetti siano gli elementi di quell'insieme. Tuttavia, in matematica, il [[cardinalità|numero degli elementi]] è una caratteristica intrinseca dell'insieme stesso, e risulta definito nel momento in cui si definisce l'insieme, mentre in programmazione è possibile istanziare una classe un numero di volte arbitrario (teoricamente da zero ad infinito, in pratica da zero fino a esaurimento della [[RAM|memoria di lavoro]] del calcolatore) e che dipende dall'esecuzione del programma. Per questo motivo, è preferibile considerare la classe come un modello astratto istanziabile.

In altri termini, una classe è paragonabile al [[progetto]] di un'[[infrastruttura]] che può poi essere messa in opera/esercizio ovvero realizzata o meno con l'istanziazione dei suoi oggetti tutti con le medesime caratteristiche, ovvero gli attributi (con valori diversi), su cui opereranno i metodi o funzioni.

=== Oggetti ===

{{vedi anche|Oggetto (informatica)}}

Un oggetto è una istanza di una classe. Esso è dotato di tutti gli attributi e i metodi definiti dalla classe, ed agisce come un fornitore di "messaggi" (i metodi) che il codice eseguibile del programma (procedure o altri oggetti) può attivare su richiesta.<br />

Inviare un messaggio ad un oggetto significa, in gergo, invocare un metodo su quell'oggetto. Il metodo riceve come parametro (spesso implicito) l'oggetto su cui è stato invocato, che può essere referenziato tramite una parola-chiave o una sintassi apposita, anche se è passato come parametro implicito; per esempio, in [[C++]], in [[Java (linguaggio di programmazione)|Java]], e in [[C sharp|C#]] si usa la parola-chiave <code>this</code> (<code>$this</code> in PHP), mentre in [[Smalltalk]], in [[Objective C|Objective-C]], [[Python]] e in [[Ruby (linguaggio di programmazione)|Ruby]] si usa la parola-chiave <code>self</code>.

Dal punto di vista del calcolatore, ogni oggetto è identificato da una certa [[memoria RAM|zona di memoria]], nella quale sono memorizzati gli ''[[Attributo (programmazione)|attributi]]'', e il valore di questi ultimi determina lo stato interno dell'oggetto. ''Istanziare'' un oggetto vuol dire [[allocazione della memoria|allocare]] memoria ed eventualmente inizializzarla secondo le specifiche definite dalla classe. Molti linguaggi forniscono un supporto per l'inizializzazione automatica di un oggetto, con uno o più metodi speciali, detti ''[[Costruttore (informatica)|costruttori]]''. Analogamente, la fine della vita di un oggetto può essere gestita con un metodo detto ''[[distruttore (informatica)|distruttore]]''.

Il codice eseguibile del programma accede a tale zona di memoria sempre e solo secondo le modalità definite dalla classe.<br />

Secondo il principio noto come ''[[#Incapsulamento|information hiding]]'', l'accesso ai campi di un oggetto deve essere permesso solo tramite metodi invocati su quello stesso oggetto. Il vantaggio principale è che il controllo completo sullo stato interno viene assegnato ad una zona ristretta del codice eseguibile del programma (la classe), perché il codice esterno non è autorizzato a modificarlo. In tal caso, risulta possibile imporre dei vincoli sui possibili valori che la [[tupla]] degli attributi può o non può assumere, e anche sulle possibili transizioni tra questi stati. Un oggetto quindi può essere visto come una [[Automa a stati finiti|macchina a stati finiti]].

== Incapsulamento ==

{{Vedi anche|Incapsulamento (informatica)}}

L<nowiki>'</nowiki>''incapsulamento'' è la proprietà per cui i dati che definiscono lo stato interno di un oggetto e i metodi che ne definiscono la logica sono accessibili ai metodi dell'oggetto stesso, mentre non sono visibili ai client. Per alterare lo stato interno dell'oggetto, è necessario invocarne i metodi pubblici, ed è questo lo scopo principale dell'incapsulamento. Infatti, se gestito opportunamente, esso permette di vedere l'oggetto come una ''[[Modello black box|black-box]]'', cioè una "scatola nera" con la quale l'interazione avviene solo e solamente tramite i metodi definiti dall'interfaccia. Il punto è dare delle funzionalità agli utenti nascondendo i dettagli legati alla loro implementazione. Un esempio potrebbe essere un oggetto "matematica" che tra le tante operazioni che fornisce ce n'è una che moltiplica due numeri. Per esempio <kbd>moltiplica(2,3)</kbd> restituisce 6. Adesso l'algoritmo di moltiplicazione può essere uno dei tanti algoritmi che esistono però questo per chi chiama il metodo <kbd>moltiplica()</kbd> non fa nessuna differenza. L'importante è che il risultato non sia errato.

== Ereditarietà ==

{{Vedi anche|Ereditarietà (informatica)}}

Il meccanismo dell<nowiki>'</nowiki>''[[Ereditarietà (informatica)|ereditarietà]]'' è utilizzato in fase di strutturazione/definizione/pianificazione del software o in successive estensioni e permette di derivare nuove classi a partire da quelle già definite realizzando una gerarchia di classi. Una classe derivata attraverso l'ereditarietà (''sottoclasse'' o classe figlia) mantiene i metodi e gli attributi delle classi da cui deriva (''classi base'', ''superclassi'' o classi madre); inoltre, può definire i propri metodi o attributi, e ridefinire il codice di alcuni dei metodi ereditati tramite un meccanismo chiamato ''[[overriding]]''.

Quando una classe eredita da una sola superclasse si parla di eredità singola; viceversa, si parla di eredità multipla. Alcuni linguaggi (tra gli altri, Java, Smalltalk) forniscono supporto esclusivo all'ereditarietà singola. Altri (C++, Python) prevedono anche l'ereditarietà multipla.

Alcuni linguaggi tipizzati (Java, C#) prevedono l'ereditarietà delle interfacce, oltre che delle classi.

L'ereditarietà può essere usata come meccanismo per ottenere l'estensibilità e il riuso del codice, e risulta particolarmente vantaggiosa quando viene usata per definire [[#Sottotipizzazione|sottotipi]], sfruttando le relazioni ''is-a'' esistenti nella realtà di cui la struttura delle classi è una modellizzazione. Oltre all'evidente riuso del codice della superclasse, l'ereditarietà permette la definizione di codice generico attraverso il meccanismo del polimorfismo.

; Esempio

Se nel programma esiste già una classe <kbd>MezzoDiTrasporto</kbd> che ha come proprietà i dati di posizione, velocità, destinazione e carico utile, e occorre una nuova classe <kbd>Aereo</kbd>, è possibile crearla direttamente dall'oggetto <kbd>MezzoDiTrasporto</kbd> dichiarando una classe di tipo <kbd>Aereo</kbd> che eredita da <kbd>MezzoDiTrasporto</kbd> e aggiungendovi anche l'attributo che identifica la [[quota di crociera]], con il vantaggio che la nuova classe acquisirà tutti i membri definiti in <kbd>MezzoDiTrasporto</kbd> per il fatto stesso di esserne sottoclasse.

=== Sottotipizzazione ===

{{vedi anche|Sottotipo (informatica)}}

Sebbene concettualmente esistano delle differenze ben marcate, il meccanismo di eredità fra classi (''subclassing''), attraverso il meccanismo del polimorfismo per inclusione, permette nei linguaggi ad oggetti di modellare l'eredità fra tipi (''subtyping'').

Secondo il [[principio di sostituzione di Liskov]], un tipo <kbd>S</kbd> è un ''sottotipo'' di <kbd>T</kbd> quando è possibile sostituire tutte le istanze di <kbd>T</kbd> con delle istanze di <kbd>S</kbd> mantenendo intatto il funzionamento del programma.

Con gli opportuni accorgimenti è possibile creare una relazione di classe-sottoclasse che rispetti anche i vincoli della relazione tipo-sottotipo. Da un punto di vista sintattico, ciò richiede che tutti i metodi della superclasse siano presenti nella sottoclasse, e che le rispettive ''[[Firma (programmazione)|signature]]'' siano compatibili. Di conseguenza, una sottoclasse che voglia definire un sottotipo può ridefinire i metodi della superclasse, ma non può eliminarli. La ''signature'' dei metodi può essere solo parzialmente modificata, rispettando dei vincoli sulla variazione dei parametri rispetto alla catena di eredità.

Tuttavia, il rispetto delle restrizioni sintattiche non è sufficiente, da solo, ad assicurare il rispetto della condizione di Liskov: la [[overriding|ridefinizione dei metodi]] o la {{chiarire|riassegnazione degli attributi}}, infatti, potrebbe compromettere la compatibilità in tempo di esecuzione.

In molti linguaggi, nella definizione di una sottoclasse, si può decidere di eliminare o cambiare le proprietà di accesso a un metodo ereditato. In tal caso, l'operazione di ''subclassing'' non corrisponde a quella di ''subtyping''. Alcuni linguaggi a oggetti, in particolare [[Sather]], dividono esplicitamente a livello sintattico subclassing e subtyping.

In linguaggi con [[tipizzazione statica]] ed [[tipizzazione esplicita|esplicita]], la sottotipizzazione viene supportata attraverso il polimorfismo per inclusione delle sottoclassi: una stessa variabile può fare riferimento ad un oggetto del tipo per cui è stata dichiarata, o di tipi da esso derivati. Il tipo dell'oggetto individuato dalla variabile, quindi, viene definito a [[runtime]] ([[binding dinamico]]), e può essere modificato durante l'esecuzione del programma.

== Polimorfismo ==

{{Vedi anche|Polimorfismo (informatica)}}

Nella programmazione ad oggetti, con il nome di polimorfismo per inclusione, si indica il fatto che lo stesso codice eseguibile può essere utilizzato con istanze di classi diverse, aventi una ''superclasse'' comune.

=== Binding dinamico o polimorfismo orizzontale ===

{{vedi anche|Binding}}

Il [[polimorfismo (informatica)|polimorfismo]] è particolarmente utile quando la versione del metodo da eseguire viene scelta sulla base del tipo di oggetto effettivamente contenuto in una variabile a ''runtime'' (invece che al momento della [[compilatore|compilazione]]). Questa funzionalità è detta ''[[Binding|binding dinamico]]'' (o late-binding), ed è supportato dai più diffusi linguaggi di programmazione ad oggetti.

Se una variabile di tipo <kbd>A</kbd> ha due sottotipi (sottoclassi) <kbd>B</kbd> e <kbd>C</kbd>, che ridefiniscono entrambe il metodo <kbd>m()</kbd>, l'oggetto contenuto nella variabile potrà essere di tipo <kbd>A</kbd>, <kbd>B</kbd> o <kbd>C</kbd>, e quando sulla variabile viene invocato il metodo <kbd>m()</kbd> viene eseguita la versione appropriata per il tipo di oggetto contenuto nella variabile in quel momento.

Per ritornare all'esempio precedente, si suppone che un <kbd>Aereo</kbd> debba affrontare procedure per l'arrivo e la partenza molto più complesse di quelle di un normale camion, come in effetti è: allora le procedure <kbd>arrivo()</kbd> e <kbd>partenza()</kbd> devono essere cambiate rispetto a quelle della classe base <kbd>MezzoDiTrasporto</kbd>. Si provvede quindi a ridefinirle nella classe <kbd>Aereo</kbd> in modo da ottenere il comportamento necessario (polimorfismo): a questo punto, dalla lista di mezzi è possibile prendere qualsiasi mezzo e chiamare <kbd>arrivo()</kbd> o <kbd>partenza()</kbd> senza più doversi preoccupare di che cos'è l'oggetto che si sta maneggiando: che sia un mezzo normale o un aereo, si comporterà rispondendo alla stessa chiamata sempre nel modo giusto.

Il supporto al ''binding dinamico'' non è necessariamente automatico in tutti i linguaggi di programmazione ad oggetti. Ad esempio in Java, Smalltalk, Python, Ruby, il ''binding dinamico'' è implicitamente usato come comportamento di default nelle classi polimorfe, mentre in C++ viene abilitato inserendo la keyword ''virtual'' nella signature del metodo interessato.

Il supporto runtime di una chiamata di metodo polimorfa richiede che a una variabile polimorfa venga associato un metadato implicito che contiene il tipo del dato contenuto nella variabile in un dato momento, oppure la tabella delle funzioni polimorfe.

==== Esempio - Binding dinamico ====

Si supponga di avere il seguente pseudo codice in Java dove <kbd>Classe2</kbd> è una sottoclasse di <kbd>Classe1</kbd>:

<syntaxhighlight lang="java">

void metodo(int input) {

Classe1 c;

if (input > 0)

c = new Classe1();

else

c = new Classe2();

c.faiQualcosaDiImportante();

}

</syntaxhighlight>

Si noti che <kbd>faiQualcosaDiImportante</kbd> è un metodo definito da <kbd>Classe1</kbd> ma potrebbe essere stato ridefinito in <kbd>Classe2</kbd> (perché magari deve essere stampato in maniera diversa). Il compilatore non può sapere a tempo di compilazione se <kbd>c</kbd> è un oggetto associato alla classe <kbd>Classe1</kbd> o <kbd>Classe2</kbd>. Tramite il binding dinamico la scelta su quale metodo effettivamente ''linkare'' sarà effettuata durante l'esecuzione (''runtime''), quando il metodo viene effettivamente chiamato.

=== Polimorfismo verticale ===

Con l'espressione polimorfismo verticale si intende la possibilità di ridefinire o riutilizzare metodi anche in classi derivate.

== Problemi dei linguaggi OOP ==

{{c|Sezione dilettantesca, priva di fonti. La scelta dei "problemi" dei linguaggi OOP sembra assolutamente arbitraria e discutibile. Da sostituire con una sezione sulle critiche al paradigma basata su fonti secondarie.|informatica|ottobre 2014}}

Alcuni meccanismi inclusi nella gestione degli oggetti causano un overhead in termini di tempo e memoria, che in determinate situazioni può portare a problemi di efficienza.

Alcuni linguaggi come [[Java (linguaggio di programmazione)|Java]] e [[C++]] preferiscono un approccio ibrido rispetto all'OOP "puro", ad esempio del linguaggio [[Smalltalk]], prevedendo che alcuni tipi di dati primitivi non siano considerati come oggetti. I vantaggi di quest'approccio sono particolarmente evidenti in presenza di computazioni numeriche; di contro, ogni volta che è necessario un oggetto in luogo di un tipo primitivo è necessario ricorrere ad un apposito ''wrapper'', e questo può portare a cali prestazionali.

Tale wrapper può anche essere dato automaticamente dal linguaggio stesso, come nel caso del Java o del [[C#]], tramite una conversione automatica chiamata "autoboxing" (inscatolamento automatico). Essa permette di mettere valori di tipi primitivi (es. interi, caratteri) all'interno di oggetti, quindi di richiamare parti di codice che vorrebbero oggetti senza scrivere esplicitamente l'istruzione di creazione dell'oggetto che racchiude il valore. Tale inscatolamento risolve il problema di scrivere un wrapper a mano, ma ovviamente il calo di prestazioni rimane.

Altre critiche all'OOP riguardano la maggiore complessità strutturale rispetto ai linguaggi procedurali, a fronte delle limitazioni introdotte per seguire il paradigma a oggetti. Esistono inoltre alcune carenze concettuali (in particolare riguardo alla sottotipizzazione), che aggiunte alle diverse implementazioni nei linguaggi possono causare problemi al programmatore. Ad esempio il funzionamento in contesti polimorfi non è garantito quando i metodi vengano ridefiniti in una catena di eredità. Inoltre cambiare le definizioni nelle classi base può portare a introdurre errori in cascata nelle sottoclassi ([[problema della classe base fragile]]).

== Note ==

<references/>

== Bibliografia ==

* {{RivistaVG|mc|101|272-275|11|1990|titolo=Introduzione alla programmazione orientata all'oggetto - Prima parte}}

* {{RivistaVG|mc|102|241-245|12|1990|titolo=Introduzione alla programmazione orientata all'oggetto - Seconda parte}}

== Voci correlate ==

* [[Progettazione orientata agli oggetti]]

* [[Programmazione ad eventi]]

* [[Programmazione orientata agli aspetti]]

* [[Base di dati a oggetti]]

* [[Copia di un oggetto]]

* [[Unified Modeling Language]]

== Collegamenti esterni ==

* {{Collegamenti esterni}}

* {{cita web|http://www.bluej.org|bluej: Ambiente di sviluppo open source per l'insegnamento della programmazione ad oggetti (in Java)}}

* [https://www.html.it/guide/guida-programmazione-orientata-agli-oggetti/ Guida programmazione orientata agli oggetti] La guida, oltre a fornire la teoria di base della OOP, è ricca di esempi pratici in tutti i linguaggi più usati dagli sviluppatori web: da C# a Actionscript, fino a Java e Python.

{{Paradigmi di programmazione}}

{{Controllo di autorità}}

{{Portale|informatica}}

[[Categoria:Programmazione orientata agli oggetti| ]]