Riassunto esame metodologie di programmazione, prof. Cenciarelli

Metodologie di programmazione

Incapsulamento

Incapsulamento, detto anche data hiding, è un meccanismo in cui gli attributi dell'oggetto e i metodi agiscono come una singola unità. Infatti, gli attributi saranno accessibili solo tramite i metodi della classe. Un esempio di incapsulamento è l'uso di variabili con l'implementazione di un getter e setter per tali variabili. Il beneficio di ciò è che la classe può avere totale controllo sui suoi attributi e inoltre si può scegliere se trattare alcuni attributi come di sola lettura o di sola scrittura.

Ereditarietà

Si dice che una classe C2 è una sottoclasse di C1 (e analogamente che C1 è una superclasse di C2) quando:

• C2 eredita il comportamento di C1
• Un’istanza della classe C2 è utilizzabile quando è richiesto l’uso di un’istanza di C1.

Una classe non può essere “estesa” ed avere sottoclassi. Ogni istanza della classe C2 sarà anche di tipo C1 e avrà a disposizione tutti i metodi e attributi di C1. Si dichiara in questo modo:

Si dice che C2 è sottoclasse di C1, e C1 è superclasse di C2.

public class C2 extends C1 { ... }

Dentro la classe C2 sarà possibile avere un riferimento a C1 tramite il riferimento super. Alcune interazioni tra sottoclasse e superclasse sono:

• Overloading: “potenzia” un metodo della superclasse dichiarandolo nuovamente nella sottoclasse ma con diversi parametri in modo da non sovrascriverlo.
• Overriding: sovrascrive un metodo della superclasse dichiarandolo nuovamente all’interno della sottoclasse con gli stessi parametri di input. Nel caso vi sia un overriding da parte di una sottoclasse, la risoluzione del metodo è dinamica, ovvero, viene deciso a runtime se verrà usato il metodo della superclasse o della sottoclasse in base all’oggetto che lo chiama.

Quindi, se creo un oggetto Quadrato che estende Figura:

Figura prova = new Quadrato();

Non posso usare un metodo di Quadrato che Figura non ha (a meno che non usi il late binding). La risoluzione di chiamate ad attributi è statica, ovvero userà comunque il metodo della superclasse anche se viene sovrascritto.

Polimorfismo

È la capacità di un oggetto che ha più sottoclassi di assumere automaticamente più forme, e quindi diversi comportamenti. Poniamo il caso in cui si abbia una classe Figure con sottoclassi: Triangolo, Rettangolo, Cerchio. A questo punto posso creare un array di figure e posso memorizzarci tante figure di tipo diverso:

Figure[] disegno = new Figure[100];

disegno[0] = new Cerchio();

disegno[1] = new Triangolo();

disegno[2] = new Rettangolo();

Problema: lanciando disegno[0].perimetro() si fa credere al compilatore di star lanciando perimetro() sulla classe Figure, ma Figure non ha un metodo perimetro quindi si usa il Late Binding (usare un metodo come segnaposto in una superclasse ma in realtà verrà sempre chiamato il metodo della sottoclasse).

Astrazione

L’astrazione è il concetto che indica “l’abilità di concentrarsi solo sulle cose essenziali nella descrizione di un’entità”. Essa si applica ogni volta che creiamo un metodo (astrazione funzionale), poiché definiamo un’azione o quando creiamo una classe (astrazione dei dati), raccogliendo le caratteristiche essenziali dell’oggetto o quando definiamo un’applicazione nei termini delle classi essenziali che la compongono (astrazione del sistema).

Classi

Una classe è il prototipo di un oggetto in cui vengono definiti tutti i messaggi che l’oggetto può ricevere, composto dall’insieme dei metodi (messaggi che può ricevere/azioni che può compiere) e degli attributi (stato dell’oggetto). Dentro una classe, si usa il riferimento this per indicare la particolare istanza della classe stessa su cui ad esempio un metodo/costruttore viene usato.

Costruttore

È quel metodo di una classe il cui compito è proprio quello di creare nuove istanze di una classe. Possono esserci molteplici costruttori per una medesima classe (ognuno con parametri diversi) e ne esiste sempre almeno uno.

Costruttori di default

Se per una data classe non viene specificato alcun costruttore, viene generato automaticamente dal compilatore il costruttore di default equivalente a:

public <NomeClasse>() {}

Metodi

Sono blocchi di codice che possono essere riutilizzati in modo semplice, essi se non sono di tipo void ritornano sempre un valore e sono identificati univocamente dal loro identificatore e dai loro parametri. Stesso identificatore e diversi parametri indicano un overloading del metodo, e sarà il compilatore a gestirlo nel caso il metodo venga chiamato (N.B. I metodi sono implicitamente Default).

[public|protected|private] [static] [final] Tipo identificatore([Tipo1 parametro1, Tipo2 parametro2, ..., TipoN parametroN]) [throws Eccezione1, Eccezione2, ...] { // blocco di codice appartenente al metodo return varTipo; }

Metodi: Passaggio per riferimento e passaggio per valore

Le variabili associate a tipi primitivi (int, String, float, boolean…) sono passate a un metodo per valore. Cioè, viene fatta una copia e questa è passata al metodo. Modifiche al valore passato non influenzano la variabile nel codice che richiama il metodo:

void A_method(int k) { int i = 10 * k; k = 5; } ... int i = 2; A_Class a = new A_Class(); a.A_method(i); j = i; // ma j = i = 2 non 5...

Gli oggetti sono passati ai metodi per riferimento. Perciò l'oggetto referenziato può essere modificato dal metodo. Tuttavia, l’indirizzo del riferimento è passato per valore quindi se si sostituisce il riferimento con un nuovo oggetto e alterandolo, l’oggetto di partenza non viene modificato.

void A_method(B_Class bb) { bb.j = 20; // questo cambia la variabile j dell’oggetto di partenza... bb = new B_Class(); // mette un nuovo oggetto all’indirizzo bb bb.j = 100; // dunque non altera l’oggetto di partenza! }

Classi generiche

Sono classi parametricamente polimorfiche, perché non si conoscono a priori alcune classi utilizzate all’interno.