2013

Corso JAVA 7
Lezione 4
Questo corso, basato sull’ultima versione del linguaggio Java, con nome in
codice Dolphin, cerca di fornire ai lettori le informazioni necessarie per iniziare a
programmare con Java. In questa lezione verranno descritti alcuni paradigmi
della programmazione orientata agli oggetti quali l’astrazione, il riuso del
codice, l’incapsulamento e l’ereditarietà.

Dott. Giuseppe Liccardo

Università degli Studi di Napoli “Parthenope”
12/02/2013
Bibliografia
[1] Manuale di Java 7 – Claudio de Sio – Hoepli Informatica – 2011. [LINK]
[2] Analista Programmatore Java – CPU Academy – 2011. [LINK]
[3] Java SE Documentation – Oracle/Sun. [LINK]
[4] Corso Java – html.it. [LINK]
[5] Corso Java – mrwebmaster.it. [LINK]
[6] Java Fondamenti di Programmazione – Deitel&Deitel – Apogeo – 2005. [LINK]
[7] Java Tecniche Avanzate di Programmazione – Deitel&Deitel – Apogeo – 2005.
[LINK]
[8] Laboratorio di Introduzione alla Programmazione – Università di Pisa. [LINK]
[9] Programmazione 3 – Montella – Università di Napoli “Parthenope”. [LINK]
[10] Thinking in Java Vol. 1 I Fondamenti – Bruce Eckel – Brossura – 2006. [LINK]
[11] Thinking in Java Vol. 2 Tecniche Avanzate – Bruce Eckel – Brossura – 2006. [LINK]
[12] Thinking in Java Vol. 3 Concorrenza e Interfacce Grafiche – Bruce Eckel –
Brossura – 2006. [LINK]
[13] Manuale pratico di Java Vol. 1 – Mokabyte – Hops – 2003. [LINK]
[14] Manuale pratico di Java Vol. 2 – Mokabyte – Hops – 2003. [LINK]

Si ringraziano gli autori delle fonti sopracitate.

Indice

LEZIONE 4 ................................................................................................................................1
1.1 Paradigmi della programmazione ad oggetti.................................................................2
1.2 Astrazione ....................................................................................................................2
1.3 Riuso del codice ...........................................................................................................3
1.4 Incapsulamento.............................................................................................................3
1.4.1 Concetto ........................................................................................................4
1.4.2 Esempio pratico ..............................................................................................5
1.4.3 Incapsulamento funzionale ..............................................................................8
1.4.4 Reference THIS ...............................................................................................9
1.5 Ereditarietà .................................................................................................................10
1.5.1 Concetto ...................................................................................................... 11
1.5.2 Relazione “is a”............................................................................................. 11
1.5.3 Generalizzazione e specializzazione ............................................................... 12
1.5.4 Rapporto ereditarietà – incapsulamento ......................................................... 12
1.5.5 Esempio pratico ............................................................................................ 13
1.5.6 Conclusioni .................................................................................................. 14
 1

LEZIONE 4

OOP: Astrazione, Riuso, Incapsulamento, Ereditarietà

In questa lezione verranno elencati alcuni dei paradigmi fondamentali della

programmazione orientata agli oggetti.

Inizialmente verranno formalizzati i concetti di astrazione e riuso del codice.

Successivamente, verranno approfonditi l’incapsulamento ed i vantaggi che si hanno

mediante il suo utilizzo.

Infine, verrà trattata l’ereditarietà e la sua implementazione mediante la parola chiave

extends.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 2

1.1 Paradigmi della programmazione ad oggetti

Esistono svariati paradigmi relativi alla programmazione orientata agli oggetti, alcuni dei

quali non sono propriamente specifici per questo tipo di programmazione, come l’astrazione

o il riuso del codice, mentre altri lo sono, come l’incapsulamento, l’ereditarietà e il

polimorfismo.

Il concetto di programmazione ad oggetti è un concetto molto esteso. Si può dire che

l’elemento essenziale è l’astrazione, ovvero il processo per il quale descriviamo in maniera

essenziale una certa cosa. Se questo elemento viene combinato con altri elementi quali

l’incapsulamento, l’ereditarietà e il polimorfismo, allora si può raggiungere l’essenza finale

della programmazione ad oggetti, cioè il riuso del codice per lo sviluppo di altro software.

Oggi, ogni software house esistente sfrutta proprio la proprietà del riuso del codice per

velocizzare il processo produttivo e per l’implementazione delle nuove funzionalità. Quindi

la base del codice sarà la prima versione e quelle successive saranno solo ed esclusivamente

un’estensione delle funzionalità previste inizialmente e, se il codice è stato scritto con

intelligenza, sarà possibile aggiungere funzionalità senza andare a modificare il codice scritto

precedentemente.

1.2 Astrazione

L’astrazione è il concetto che indica “l’abilità di concentrarsi solo sulle cose essenziali nella

descrizione di un’entità”. Essa viene utilizzata per gestire al meglio la complessità di un

programma.

Esistono tre livelli di astrazione per quanto riguarda la sua implementazione nella

programmazione ad oggetti:

- astrazione funzionale, che viene adoperata ogni volta che si implementa un metodo;

infatti, mediante un metodo, si riesce a portare all’interno di un’applicazione

un’azione, una funzione

- astrazione dei dati, che viene adoperata ogni volta che definiamo una classe; infatti,

mediante una classe, si riesce a raccogliere soltanto le caratteristiche e le funzionalità

essenziali degli oggetti che essa deve definire nel contesto in cui ci si trova

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 3

- astrazione del sistema, che viene adoperata ogni volta che definiamo un’applicazione

nei termini delle classi essenziali che devono soddisfare agli scopi dell’applicazione

stessa

Inoltre, è possibile affermare che l’astrazione del sistema “contiene” l’estrazione dei dati che,

a sua volta, “contiene” l’astrazione funzionale.

Per rendere più chiare le idee è utile descrivere un esempio pratico.

Consideriamo una classe Animale, che incapsuli al suo interno tutte le caratteristiche (metodi

e attributi) che sono comuni a tutti gli animali. Ad esempio, si potranno definire i metodi

mangia() e respira() e gli attributi altezza e peso (solo per citarne alcuni). Ma, riflettendoci un

attimo, appare chiaro che creare un’istanza di un oggetto Animale ha poco senso visto che è

certamente più consono definire le istanze di oggetti specifici come Cavallo, Cane, Gatto, ecc.

In un simile contesto la classe Animale, non potendo essere direttamente istanziata,

rappresenta un dato astratto ed è denominata, in OOP, classe astratta, ovvero una classe che

rappresenta, fondamentalmente, un modello per ottenere delle classi derivate più specifiche

e più dettagliate.

1.3 Riuso del codice

L’utilizzo dell’astrazione facilita il riutilizzo del codice e snellisce il disegno di un sistema

software. Quindi il riuso è da considerarsi una conseguenza dell’astrazione e degli altri

paradigmi della programmazione ad oggetti.

Esso consente un risparmio notevole nei tempi di scrittura di un programma da parte del

programmatore, facilitando il lavoro di programmazione e migliorando la leggibilità del

codice divenuto più corto e sintetico, ed è per questo presente in quasi tutti i linguaggi di

programmazione, tra cui Java.

1.4 Incapsulamento

L’idea di base dell’incapsulamento è quella di controllare l’accesso degli attributi di una

classe utilizzando dei metodi per la gestione degli stessi.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 4

1.4.1 Concetto

Grazie al concetto di incapsulamento, il codice di una classe risulta essere più robusto, cioè

meno esposto ad errori derivanti dall’errato utilizzo dell’applicazione da parte dell’utente.

Inoltre, la manutenzione del codice della classe stessa risulterà essere più semplice al

programmatore, per cui risulterà essere più semplice effettuare modifiche o introdurre

nuove migliorie.

Una qualsiasi classe è costituita da dati e metodi. L’incapsulamento si basa sull’accesso

controllato ai dati mediante metodi che possono prevenirne l’usura e non correttezza.

Questo, a livello di implementazione significa:

1. dichiarare privati, mediante il modificatore private, gli attributi di una classe,

rendendoli quindi inaccessibili al di fuori della classe stessa

2. accedere ai dati mediante un’interfaccia pubblica, costituita da metodi dichiarati

pubblici, mediante il modificatore public, quindi accessibili al di fuori della classe

In questo modo, ad esempio, tali metodi potrebbero essere utilizzati per effettuare dei

controlli sui valori che potranno assumere i dati prima di accedere ai dati stessi.

In definitiva, l’incapsulamento si raggiunge rendendo gli attributi delle classi privati, cioè

non modificabili dall’esterno e creando dei metodi pubblici da utilizzare per l’accesso ai dati.

Questi metodi andranno a costituire l’interfaccia pubblica per l’accesso ai dati.

I vantaggi legati a questo approccio sono:

- l’utente della classe ha il vantaggio di chiamare semplicemente il metodo per

l’inserimento di un valore in un attributo ma non ha la necessità di conoscere come

una classe implementa quell’azione (information hiding)

- il programmatore ha il vantaggio di dover modificare solo il codice relativo

all’interfaccia nel caso in cui si vogliano introdurre migliorie o apportare modifiche

(dal punto di vista dell’utente non occorre modificare nulla in quanto l’utente

continuerà ad usare la stessa interfaccia senza essere al corrente delle eventuali

modifiche apportate)

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 5

1.4.2 Esempio pratico

Supponiamo di voler scrivere un’applicazione che utilizza la seguente classe Anagrafica che

rappresenta proprio un’anagrafica di una determinata persona.

public class Anagrafica {

public String nome;
public int giorno;
public int mese;
public int anno;
}

Per poter istanziare un oggetto Anagrafica occorre scrivere il seguente codice.

...
Anagrafica persona = new Anagrafica();
persona.nome = “Giuseppe Liccardo”;
persona.giorno = 16;
persona.mese = 11;
persona.anno = 1987;
...

In questo modo, però, potrebbero nascere dei problemi in quanto non sono effettuati dei

controlli sui possibili valori che possono essere assunti dalle variabili. Per risolvere questo

tipo di problemi si potrebbe modificare il codice dove si istanzia il nuovo oggetto. In questo

caso, però, non si potrebbe riutilizzare lo stesso codice in un’altra applicazione ed

occorrerebbe riscrivere nuovo codice per la nuova applicazione.

Qui ci viene incontro l’incapsulamento. Mettiamo in atto i principi dell’incapsulamento

esposti nel paragrafo precedente.

Prima di tutto occorre rendere gli attributi della classe in modo tale che non siano

direttamente accessibili dall’esterno. Ciò si ottiene dichiarando privati gli attributi della

classe usando il modificatore di visibilità private.

Successivamente occorre creare un’interfaccia pubblica da utilizzare per accedere ai dati.

Quest’interfaccia sarà costituita da due tipi di metodi pubblici:

- i mutator methods (o metodi “set”) che servono per accedere ai dati in scrittura

- gli accessor methods (o metodi “get”) che servono per accedere ai dati in lettura

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 6

Andiamo ora a riscrivere la classe Anagrafica usando il concetto di incapsulamento.

public class Anagrafica {

private String nome;
private int giorno, mese, anno;
}

N.B. La classe è ancora incompleta in quanto mancano i controlli sui valori.

Con questo codice si va a bloccare l’accesso diretto ai dati dall’esterno, infatti nel caso in cui

istanziassimo la classe col codice visto in precedenza e cercassimo di accedere ad un attributo

usando l’operatore “dot”, riceveremmo un errore dal compilatore in cui ci avverte che le

variabili non sono visibili.

Adesso non ci resta che creare un interfaccia pubblica, costituita da metodi pubblici, da usare

per poter accedere ai dati. Estendiamo, quindi, il codice della classe Anagrafica.

public class Anagrafica {

private String nome;
private int giorno, mese, anno;

// Metodi “set” e “get” per la variabile nome

public void setNome (String n) {

nome = n;
}

public String getNome () {

return nome;
}

// Metodi “set” e “get” per la variabile giorno

public void setGiorno (int g) {

if (g>=1 && g<=31)
giorno = g;
else
System.out.println(“Giorno non valido”);
}

public int getGiorno () {

return giorno;
}

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 7

// Metodi “set” e “get” per la variabile mese

public void setMese (int m) {
if (m>=1 && m<=12)
mese = m;
else
System.out.println(“Mese non valido”);
}

public int getMese () {

return mese;
}

// Metodi “set” e “get” per la variabile anno

public void setAnno (int a) {
if (a>=1880 && a<=2013)
anno = a;
else
System.out.println(“Anno non valido”);
}

public int getAnno () {

return anno;
}
}

Abbiamo dunque creato due interfacce pubbliche per ogni attributo della classe: uno per

l’assegnazione del valore e uno per recuperare il valore dell’attributo.

Scriviamo ora il codice per istanziare un oggetto della classe Anagrafica.

public class Implementazione {

public static void main(String[] args) {
Anagrafica persona = new Anagrafica();
persona.setNome(“Giuseppe Liccardo”);
persona.setGiorno(16);
persona.setMese(11);
persona.setAnno(1987);

System.out.print(persona.getNome());
System.out.print(persona.getGiorno());
System.out.print(persona.getMese());
System.out.print(persona.getAnno());
}
}

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 8

Per poter sfruttare i dati della classe Anagrafica saremo ora costretti ad utilizzare l’interfaccia

pubblica costituita dai metodi “set” e “get” che si trovano all’interno della classe stessa e

quindi possono accedere ai dati privati.

Inoltre, i controlli realizzati per ciascun dato risolvono eventuali problemi di inserimento dei

valori. I controlli inseriti non sono completi, per cui se volessimo inserire la data 31-02-2000 il

compilatore non restituirebbe alcun errore. Il vantaggio dell’incapsulamento riguardante le

modifiche e le migliorie, consente al programmatore di introdurre questo nuovo controllo

andando a modificare solo il codice relativo al metodo e non il codice in cui si va ad

istanziare ed usare l’oggetto, per cui la classe Implementazione rimarrebbe inalterata.

1.4.3 Incapsulamento funzionale

Nell’esempio precedente abbiamo visto un caso di incapsulamento abbastanza classico, dove

si dichiaravano privati gli attributi della classe. Usando, però, il modificatore private ad un

metodo, di fatto si ottiene un incapsulamento funzionale. Un metodo privato infatti, potrà

essere invocato solo da un metodo definito nella stessa classe, che potrebbe a sua volta essere

dichiarato pubblico.

public class ContoBancario {

...
public String getContoBancario(int codiceDaTestare) {
return controllaCodice(codiceDaTestare);
}

private String controllaCodice(int codiceDaTestare) {

if (codiceDaTestare == codiceInserito)
return contoBancario;
else
return (“Codice Errato!”);
}
}

Ciò favorirebbe il riuso di codice in quanto, introducendo nuovi metodi, questi potrebbero

risfruttare il metodo controllaCodice().

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 9

1.4.4 Reference THIS

Considerando la classe Anagrafica e considerando che potrebbero essere istanziati tanti

oggetti di questa classe, ci potremmo chiedere: se giorno è una variabile d’istanza, a quale

istanza appartiene?

La risposta è: dipende “dall’oggetto corrente”, ovvero dall’oggetto su cui è chiamato il

metodo getGiorno().

Java introduce una parola chiave, this, che non è altro che un riferimento all’oggetto sul

quale il metodo è stato invocato. In ogni corpo di un metodo (o di un costruttore) è sempre

disponibile la variabile predefinita this che denota l’oggetto che sta eseguendo il metodo (o

il costruttore).

Questo reference, quindi, non fa altro che puntare all’oggetto a cui appartiene risolvendo

possibili problemi di ambiguità. Esso viene implicitamente aggiunto nel bytecode compilato

per referenziare ogni variabile d’istanza non esplicitamente referenziata.

Ancora una volta, Java cerca di facilitare la vita al programmatore.

Vediamo l’utilità dell’utilizzo di questo reference. Consideriamo il seguente esempio.

public class Cliente {

private String nome, indirizzo;
private int numeroDiTelefono;
...
public void setCliente(String n, String ind, int num) {
nome = n;
indirizzo = ind;
numerDiTelefono = num;
}
}

Nell’esempio (ma anche negli esempi precedenti) abbiamo distinto le variabili d’istanza dalle

variabili locali (o parametri). In pratica, abbiamo utilizzato l’identificatore n per inizializzare

nome, l’identificatore num per inizializzare numeroDiTelefono e ind per inizializzare indirizzo.

Non c’è nulla di sbagliato in tutto questo.

La diversità tra i due concetti di variabile d’istanza e variabile locale è tale che il compilatore

ci permette di dichiarare una variabile locale e una variabile d’istanza, aventi lo stesso

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 10

identificatore, nella stessa classe. Infatti la Java Virtual Machine alloca le variabili locali e le

variabili d’istanza in differenti aree di memoria, le prima nello stack, le seconde nell’heap.

Conoscendo l’esistenza del reference this, si ha la possibilità di scrivere il seguente blocco

di codice, del tutto equivalente a quello precedente.

public class Cliente {

private String nome, indirizzo;
private int numeroDiTelefono;
...
public void setCliente(String nome, String indirizzo,
int numeroDiTelefono)
{
this.nome = nome;
this. indirizzo = indirizzo;
this.numerDiTelefono = numeroDiTelefono;
}
}

Tramite il reference this specifichiamo ce la variabile referenziata appartiene all’istanza. Di

conseguenza la variabile non referenziata sarà il parametro del metodo, senza che vi sia

ambiguità.

Questo stile di programmazione è molto utilizzato ed è da preferire in quanto non c’è

possibilità di confondere le variabili con nomi simili.

1.5 Ereditarietà

L’ereditarietà (inheritance) è una delle caratteristiche principali di Java in quanto permette di

mettere in relazione più classi che hanno caratteristiche comuni.

Utilizzando questo strumento avremo la possibilità di ereditare codice già scritto (e magari

già testato) in una classe ed ampliarlo, ottenendo così un’estensione della classe dalla quale

abbiamo ereditato il codice. In questo modo, potremmo gestire insiemi di classi

collettivamente, se queste sono accomunate da caratteristiche comuni.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 11

1.5.1 Concetto

L’idea dell’ereditarietà è semplice ma potente: quando si desidera creare una nuova classe e

c’è già una classe che include una parte del codice che si desidera implementare, è possibile

derivare la nuova classe dalla classe esistente. In questo modo, è possibile riutilizzare i campi

e i metodi della classe esistente senza doverli scrivere di nuovo.

Infatti, in Java, le classi possono essere ereditate da altre classi, in modo da ereditare campi e

metodi di quest’ultime.

Una classe che deriva da un’altra classe si chiama sottoclasse, la classe da cui è derivata la

sottoclasse si chiama superclasse.

Ad esclusione della classe Object, che non ha superclassi, ogni classe può avere una ed una

sola superclasse diretta (ereditarietà singola). In assenza di una qualsiasi superclasse, ogni

classe è implicitamente una sottoclasse della classe Object.

La classe Object è una classe che astrae il concetto di “oggetto generico” ed è di fatto la

superclasse di ogni classe.

In Java non esiste la cosiddetta ereditarietà multipla, per cui non è possibile estendere una

classe a partire da più classi. Questa funzionalità non è stata implementata in Java in quanto

è spesso causa di problemi implementativi. Tuttavia, tramite il concetto di interfaccia, Java

offre supporto ad un meccanismo di simulazione dell’ereditarietà multipla.

Per implementare l’ereditarietà si utilizza la parola chiave extends.

public class NomeSottoclasse extends NomeSuperclasse {

...
}

1.5.2 Relazione “is a”

Quando si parla di ereditarietà si è spesso convinti che per implementarla basti avere un paio

di classi che dichiarino campi in comune. In realtà ciò non è vero! Per determinare se una

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 12

classe può essere ereditata a partire da un’altra classe è necessario che sia effettuato la

cosiddetta “is a” relationship (la relazione “è un”).

In pratica la domanda da porsi sarà: un oggetto della candidata sottoclasse “è un” oggetto

della candidata superclasse? Se la risposta alla domanda è negativa, l’ereditarietà no si deve

utilizzare.

1.5.3 Generalizzazione e specializzazione

Sono due termini che definiscono i processi che portano all’implementazione

dell’ereditarietà.

Si parla di generalizzazione se, a partire da un certo numero di classi, si definisce una

superclasse che ne raccoglie le caratteristiche comuni.

Si parla di specializzazione se, partendo da una classe, si definiscono una o più sottoclassi

allo scopo di ottenere oggetti più specializzati.

1.5.4 Rapporto ereditarietà – incapsulamento

Abbiamo già detto che estendere una classe significa ereditarne i membri non privati. Per

questo motivo, quando estendiamo una classe non vengono ereditati tutti gli attributi e i

metodi della classe ma bensì solo quelli dichiarati public.

Quindi, utilizzando l'incapsulamento degli attributi della classe dichiarandoli come privati,

quest'ultimi non verranno direttamente ereditati. Però, negli esempi precedenti, i metodi che

si occupano della manipolazioni degli attributi (i metodi “get” e “set”) sono stati dichiarati

come pubblici e quindi verranno correttamente ereditati. Automaticamente, ereditando i

metodi che gestiscono gli attributi, avremo modo di accedere agli attributi stessi e quindi

incapsulamento ed ereditarietà possono convivere senza nessun problema.

Morale della favola: anche se la sottoclasse non possiede esplicitamente le variabili private

della sua superclasse, può comunque accedervi mediante l’incapsulamento, quindi è come se

le possedesse virtualmente.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 13

1.5.5 Esempio pratico

public class Automobile {

// variabili
public int cilindrata;
public int velocita;

// costruttore
public Automobile(int cil, int vel) {
cilindrata = cil;
velocita = vel;
}

// metodi
public void setCilindrata(int cilindrata) {
this.cilindrata = cilindrata;
}

public void setVelocita(int velocita) {

this.velocita = velocita;
}

public void frena(int frenata) {

this.velocita -= frenata;
}

public void accelera(int accelerazione) {

this.velocita += accelerazione;
}

Con questa classe descriviamo un oggetto di tipo Automobile che ha:

- la cilindrata e la velocità come caratteristiche

- setVelocita() e SetCilindrata() come metodi che permettono di impostare tali variabili

- frena() e accelera() come metodi che permettono di aumentare o diminuire il valore

della velocità

Definiamo ora una sottoclasse della classe Automobile che ne eredita quindi tutti i membri. Il

nome di questa classe è Utilitaria e andrà ad aggiungere ulteriori campi a quelli ereditati

dalla superclasse.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”
 14

public class Utilitaria extends Automobile {

// variabili
public int numeroPorte;

// costruttore
public Utilitaria(int nPorte, int cil, int vel) {
numeroPorte = nPorte;
super(cil, vel);
}

// metodi
public void setNumeroPorte(int numeroPorte) {
this.numeroPorte = numeroPorte;
}

La classe Utilitaria eredita tutti i campi e metodi della sua superclasse e aggiunge il campo

numeroPorte e un metodo setNumeroPorte().

Fatta eccezione per il costruttore, è come se avessimo scritto una nuova classe Utilitaria

interamente da zero, con tre campi e quattro metodi. Tuttavia, non è stato necessario fare

tutto questo lavoro in quanto è stato riutilizzato il codice presente nella classe Automobile.

1.5.6 Conclusioni

Le conclusioni a cui è possibile giungere sull’ereditarietà sono chiare ma non definitive. Il

concetto di ereditarietà ci ha aperto una strada con tante diramazioni: la strada della

programmazione ad oggetti. Dalla definizione dell’ereditarietà nascono fondamentali

concetti come il polimorfismo, nuove potenti parole chiave come super e ci saranno nuove

situazioni di programmazione da dover gestire correttamente.

Dalla prossima lezione in poi, quindi, ci caleremo nel supporto che Java offre alla

programmazione ad oggetti avanzata e nelle caratteristiche più complicate del linguaggio.

Corso Java 7 – Dott. Giuseppe Liccardo – Università degli Studi di Napoli “Parthenope”