Introduzione alla Programmazione orientata agli oggetti

La Programmazione Orientata agli Oggetti (OOP) è stata la rivoluzione del mondo dello sviluppo, infatti pone il programmatore davanti ad una scelta sulle tecniche di sviluppo più versatili e più implementabili nella vita reale, agli oggetti di più comune utilizzo. Grazie a questa nuova tecnica di sviluppo possiamo definire i nostri programmi con oggetti che abbiano delle caratteristiche e delle azioni, che possono contenere altri oggetti, ereditandone le stesse caratteristiche e le stesse azioni, possiamo trasformare ciò che per la realtà è palese, in codice di programmazione.

Prendiamo ad esempio i mattoncini LEGO, un esempio banale ma molto realistico e semplice da concepire: infatti è un gioco per bambini, formato da tantissimi mattoncini di plastica, di diverso colore, grandezza e forma. Ogni bambino sà perfettamente che esistono questi mattoncini con determinate caratteristiche, può usarne uno o tanti dello stesso tipo per costruire la sua creazione, quindi utilizza oggetti preimpostati dalla dimensione e dal colore. Fermandoci per il momento a queste due sole caratteristiche, il bambino costruisce un muro con i diversi mattoncini colorati, costruisce anche casette, palazzi, poi prende i mattoncini con forme differenti (come ruote o ingranaggi) e costruisce automobili, basi spaziali, ecc.

Ogni picoclo mattoncino di LEGO non è altro che un piccolo Oggetto che si combina con altri piccoli Oggetti, questo è un esempio banale ma reale di come dovremmo lavorare con la programmazione orientata agli oggetti.

Ma soffermiamoci ad analizzare il significato di oggetto: per poter essere chiamato tale deve avere delle Caratteristiche, dette anche Proprietà. Delle proprietà di esempio nei mattoncini LEGO possiamo elencarne il colore, la dimensione, il tipo e il numero di incastri disponibili: sono quattro caratteristiche fisse non modificabili che indicano al bambino quale tipo di elemento / mattoncino usare.

Possiamo quindi determinare queste proprietà come delle caratetristiche dell'oggetto Mattoncino:

// assegna il colore bianco al mattoncino
Mattoncino.colore = '#FFFFFF';

// il numero degli incastri in orizzontale
Mattoncino.x = 4;

// il numero degli incastri in verticale
Mattoncino.y = 2;

// assegnamo il tipo del mattoncino come "normale"
Mattoncino.tipo = "normale";

Oltre alle caratteristiche possiamo assegnare delle Azioni ad un oggetto, dette anche Metodi: riprendendo i LEGO facciamo l'esempio di un mattoncino di tipo porta, una sottoclasse del mattoncino normale che ne eredita tutte le caratteristiche e ne aggiunge un'altra booleana: se è aperta o se è chiusa. Naturalmente per potersi aprire o chiudere necessita di due Azioni o Metodi: Apri() e Chiudi().

Prendiamo un esempio di una Classe chiamata Persona, possiamo determinare alcune caratteristiche o meglio nominate Proprietà: Nome, Sesso, Anni, Altezza e Peso. Abbiamo in programmazione una Classe del genere:

class Persona
{
String nome;
char sesso;
int anni;
float altezza;
float peso;
public void AumentaAnni()
{
anni++;
peso++;
altezza++;
}
}
class ProvaPersona
{
public static void main(String[] args)
{
Persona pers = new Persona();
pers.nome = "Pippo";
pers.sesso = 'M';
pers.anni = 18;
pers.altezza = 123.5;
pers.peso = 75.3;
pers.AumentaAnni();
System.out.println(pers.anni + " ");
System.out.println(pers.peso + " ");
System.out.println(pers.altezza);
}
}

Abbiamo aggiunto anzhe un Metodo che oltre ad aumentare il numero degli anni, incremeta anche di un intero sia il peso che l'altezza; è un esempio molto fantasioso infatti, ma si resce a comprendere l'utilità della programmazione orientata agli oggetti in termini molto semplici.

Facciamo un altro esempio un po' più pratico, abbiamo la necesistà di memorizzare un punto sullo schermo, è possibile farlo sviluppando una classe Punto e istanziandola in un Oggetto con due caratteristiche di base, la X e la Y, ovvero i numeri di pixel che intercorrono dal lato sinistro e dal lato superiore dello schermo. Oltre a queste due caratteristiche (Proprietà x e y) dobbiamo farci scrivere il risultato sotto forma di stringa, grazie ad un Metodo (Azione)

class Punto
{
int x, y;
Punto()
{
System.out.println("default");
}
Punto(int x, int y)
{
this.x = x; this.y = y;
}
// L'istanza del Punto viene esplicitamente
// creata nella dichiarazione della classe
static Punto origine = new Punto(0,0);
// Dopo aver creato le proprietà impostiamo un Metodo
// che trasformi il punto in Stringa
public String toString()
{
return "(" + x + "," + y + ")";
}
}
class ProvaPunto
{
public static void main(String[] args)
{
Punto p = null;
try
{
// utiliziamo la forma di cattura delle eccezioni
p = (Punto) Class.forName("Punto").newInstance();
}
catch (Exception e)
{
System.out.println(e);
}
Punto a[] = { new Punto(0,0), new Punto(1,1) };
System.out.println("p: " + p);
System.out.println("a: { " + a[0] + ", " + a[1] + " }");
String sa[] = new String[2];
sa[0] = "he"; sa[1] = "llo";
System.out.println(sa[0] + sa[1]);
}
}

Come potete constatare la Classe Punto (obbligatoriamente all'esterno della funzione main) contiene due caratteristiche essenziali, x e y. Inoltre abbiamo sviluppato un Metodo che ci permette di visualizzare le coordinate del punto in formato stringa.

Una Classe viene sviluppata con delle caratteristiche e delle azioni, in seguito è possibile utilizzarla instanziandone degli Oggetti che prendono il valore delle caratteristiche e possono eseguire le azioni, già preimpostate nella Classe. Per poter istanziare un Oggetto e quindi poter accedere alle Proprietà e ai Metodi, bisogna utilizzare la parola chiave new, che assegna lo spazio di memoria necessario per l'istanza dell'Oggetto.

Una differenza sostanziale dal tipo di programmazione agli oggetti del C++ con Java è che non esistono Puntatori (oggetti specificatamente assegnati allo spazio fisico della memoria). Java si definisce più Object Based in quando utilizza l'ereditarietà, il poliformismo e l'incapsulamento degli oggetti, possiamo infatti Estendere (extend) e Implementare (implements) oggetti, utilizza le parole chiavi public, private e protected nelle dichiarazioni. In Java si possono dichiarare due o più metodi con lo stesso nome, con parametri differenti, impostarne inoltre anche uno di "default" senza parametri nel costruttore, in maniera tale da sviluppare un codice differente per ogni tipo di chiamata.