Fino alla metà degli anni 80, la programmazione era fatta con codice che veniva interpretato o compilato in maniera lineare. Si partiva dalla prima istruzione e si eseguivano i comandi uno dopo l’altro con salti logici da una sezione ad un altra e con pezzi di codice ricorrenti richiamati dal codice principale (subroutine).
In alcuni linguaggi a comandare era la linea del codice, in altri le label, ma la logica era questa : codice eseguito in maniera lineare.

Cosa comportava questo modello di programmazione ? Innanzitutto era difficile isolare logiche di programma per poterle testare singolarmente, era più complicato fare riferimento a librerie di codice poiché era essenziale la conoscenza della presenza di tale codice (se non conoscevi che esisteva tale funzione non l’avresti mai presa in considerazione).
Era più difficile l’astrazione di logiche computazionali e la creazione di modelli più vicini al nostro modo di pensare.
Il modello di programmazione lineare, limitava la capacità di sfruttare codice già creato e la possibilità di sfruttarlo ed ampliarlo implementando le nostre necessità aggiuntive.

A tutto ciò si pose rimedio con la nascita di linguaggi orientati ad oggetti.

In informatica la programmazione orientata agli oggetti (OOP, Object Oriented Programming) è un paradigma di programmazione che permette di definire 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 ad oggetti è quello delle interfacce grafiche.

Tra i primi linguaggi ad oggetti ad essere notevolmente utilizzati (ancora usatissimo oggi) è stato il Linguaggio C++, nato dal Linguaggio C che era stato creato per sviluppare essenzialmente su Unix. Dalla base del Linguaggio C sono state aggiunte le caratteristiche tipiche del linguaggio orientato agli oggetti : incapsulamento, ereditarietà e polimorfismo.

• L’incapsulamento : consiste nella separazione della cosiddetta 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’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 comune; a tempo di esecuzione, quel client attiverà comportamenti diversi senza conoscere a priori il tipo specifico dell’oggetto che gli viene passato.

Queste 3 caratteristiche permettono di creare software più facile da correggere e gestire.

Io dico sempre che un programmatore ad oggetti ha come suo principale cliente un collega, visto che ciò che realizza sarà utilizzato da altri.
E’ compito quindi del programmatore di creare oggetti chiari, ben definiti, creando subito tutte le funzionalità necessarie al suo completo funzionamento, senza trascurare parti che sul momento non saranno utilizzate.

Ma cosa è in effetti la programmazione ad oggetti ?

Partiamo dai soliti esempi semplici per poi arrivare ad esempi più complessi.

Facciamo finta di dover gestire in un programma gli animali di uno zoo.
Dobbiamo poter inserirli, modificarli, interagire e creare statistiche su di loro.

Creiamo la prima interfaccia e la chiamiamo iAnimale.

public interface iAnimale
{
   int NumeroZampe;
   bool SaVolare;
   bool SaNuotare;
   bool HaMangiato;
   bool HaCacciato;
   bool HaCorso;
   void Mangia();
   void Caccia();
   void Corre();
}

L’interfaccia è praticamente un contratto con cui definiamo le caratteristiche minime di un oggetto e abbiamo la possibilità di interfacciarci con tutti gli oggetti di questo tipo, sapendo che troveremo alcune proprietà e alcuni metodi.

A questo punto possiamo creare la nostro prima classe e la chiamiamo Felino.

public class Felino : iAnimale
{
   public int NumeroZampe = 4;
   public bool SaVolare = false;
   public bool SaNuotare = false;
   public bool HaMangiato = false;
   public bool HaCacciato = false;
   public bool HaCorso = false;
   public bool Morde = true;
   public bool Addomesticabile = false;
   private string colore = "";
   public void Felino()
   {
   }

   public void Mangia()
   {
     HaMangiato = true;
   }

   public void Caccia()
   { 
     HaCacciato = true;
   }

   public void Corre()
   {
     HaCorso = true;
   }

   public void Colora(string Colore)
   {
     this.colore = Colore;
   }
}

Questa classe ha una interfaccia iAnimale e deve obbligatoriamente avere le proprietà e i metodi esposti dall’interfaccia.
Quindi deve esporre le proprietà NumeroZampe, SaVolare, SaNuotare, HaMangiato, HaCacciato, HaCorso e i metodi Mangia, Caccia e Corre;

Ogni classe è paragonabile ad una forma con cui creare biscotti a piacimento. Abbiamo una sola forma , ma con questa possiamo creare tutti i biscotti che vogliamo.
Ogni classe ha proprietà e metodi che possono essere esposti al pubblico o essere usati all’interno privatamente.
Definendo un attributo (public o private), possiamo restringere il campo d’azione e di visibilità della proprietà o del metodo.
Le proprietà di una classe sono le caratteristiche qualificabili della stessa (colore, quantità, nome, valore ecc.), mentre i metodi sono le azioni che l’oggetto può fare.

Con questa classe possiamo creare quindi nuovi oggetti e interagire con loro.

private Felino Gatto = new Felino();
private Felino Leone = new Felino();
private Felino Pantera = new Felino();
Gatto.Addomesticabile = true;
Leone.Corre();
Pantera.Caccia();
Gatto.Colora("grigio");

Abbiamo creato alcuni oggetti di tipo Felino ed abbiamo usato le loro proprietà o i loro metodi.

Possiamo anche creare una nuova classe che erediterà dalla classe Felino le principali caratteristiche e ne aggiungerà alcune sue specifiche.

public class Ghepardo : Felino
{
   public HaCorsoVeloce = false;
   public bool Veloce = true;

   public void CorreVeloce()
   {
     HaCorsoVeloce = true;
   }
}

Questa nuova classe eredita da Felino tutte le sue caratteristiche e potrà utilizzarne di nuove.

private Ghepardo GhepardoAfricano = new Ghepardo();
GhepardoAfricano.Caccia();
GhepardoAfricano.Addomesticabile = false;
GhepardoAfricano.CorreVeloce();

Come si vede utilizza proprietà e metodi della classe Felino e metodi solo suoi.
Questo perché ha ereditato dalla classe Felino alcuni metodi, implementandone di nuovi.

Nella prossima parte descriverò i vantaggi della Programmazione ad Oggetti nella scrittura di grandi progetti come ad esempio un Sistema Operativo.