Sei sulla pagina 1di 31

Sessione 4

Classi e oggetti
(parte I)

1
Classi e Oggetti
Java un linguaggio object oriented, ovvero orienttato agli oggetti. Gi da questa definizione si capisce quindi limportanza che
hanno in Java i concetti di classi ed oggetti.
Si potrebbe dire che uno sviluppatore Java lavora sempre e solo con oggetti e classi, eccezion fatta per i tipi primitivi di cui
abbiamo gi parlato. Per inciso, occorre dire che in termini pratici e discorsivi si usano spesso le parole oggetto e classe in modo
intercambiabile; in termini tecnici, per, bisogna ricordare che le due cose sono distinte: in termini tecnici la classe il tipo di
dato, mentre loggetto una variabile di quel tipo di classe, inizializzata o istanziata (in termini tecnici si parla in modo
intercambiabile di oggetto o istanza).
La programmazione object oriented prima di tutto un modello concettuale.
Non si tratta quindi di un concetto legato al linguaggio Java. Esistono diversi linguaggi orientati agli oggetti.
La rappresentazione di un sistema attraverso il suo modello ad oggetti un concetto indipendente dal linguaggio di
programmazione che si adotter per implementare il sistema.
In ambito lavorativo esistono diverse figure professionali che operano nel mondo dellIT (Information Technology) il cui ruolo
quello di analizzare un sistema e definire il suo modello ad oggetti. Queste figure professionali, in teoria, potrebbero anche non
avere conoscenze specifiche del linguaggio di programmazione che verr poi adottato per sviluppare il sistema.

2
Riprendendo la definizione di oggetto che abbiamo dato nellintroduzione:
nei linguaggi orientati agli oggetti il dominio di un sistema viene rappresentato attraverso la definizione di alcuni oggetti che
modellano il sistema definendone le caratteristiche e le operazioni possibili su di esso.
Quindi, nella programmazione object oriented la prima cosa da fare modellare il sistema che si vuole progettare.
In un progetto reale, generalmente la complessit tale da richiedere diverse sessioni di incontri tra fornitore e cliente per definire
i requisiti del sistema e per poter quindi effettuare una modellazione del sistema in termini object oriented. Spesso occorre
ritornare indietro sulle decisioni prese e ridefinire il modello.
Ad esempio, il progetto che svilupperemo durante il corso avr come obiettivo quello di implementare unapplicazione web per
gestire le informazioni principali di un corso didattico.
Per modellare in termini object oriented un corso didattico la prima cosa da fare individuare gli oggetti principali del sistema (il
dominio).
Sicuramente ci dovr essere una classe che rappresenti il Corso.
A questo dovremmo domandarci quali siano le informazioni che descrivono un corso. Questo ci porter ad identificare gli
attributi del corso. Per esempio, un corso potrebbe essere descritto attraverso le seguenti informazioni:
docente
allievi
materia

3
aula
Potremmo iniziare quindi a definire una classe Corso in questo modo:
public class Corso {
String docente = null;
String [ ] allievi = null;
String materia = null;
String aula = null;
}
Ora dovremmo domandarci in che modo pensiamo sia possibile manipolare un corso, ovvero quali operazioni crediamo che siano
tipiche di un corso, ovvero quali saranno i suoi metodi.
Sicuramente, come molto spesso accade nelle classi Java, vorremmo esporre delle operazioni che consentano di impostare (set) e
di leggere (get) tutte gli attributi descritti precedentemente e anche delle operazioni che consentano di vedere. Ovvero delle
operazioni del tipo:
public void setDocente(String docente); // per impostare il docente del corso
public String getDocente(); // per recuperare (o leggere) il docente
Lo stesso dicasi per gli altri attributi del corso.
Unaltra operazione che potrebbe essere utile mettere a disposizione del corso unoperazione che ci consenta di sapere quanti
allievi ci sono nel corso:

4
public int getNumeroAllievi();

Operativamente, per lavorare con una classe/oggetto occorre:


1. dichiarare la classe, ovvero definire le caratteristiche che dovr possedere questo nuovo tipo di dato
2. istanziare un oggetto, ovvero creare una variabile del tipo classe definito al passo 1
3. utilizzare loggetto creato al passo 2

5
Dichiarazione di una classe
Come detto nella sessione precedente, se creiamo una classe Corso lo dovremo obbligatoriamente fare allinterno di un file di
nome Corso.java.
Ma prima ancora di creare la classe dovremo decidere la struttura di directory o package allinterno della quale creare il file
Corso.java.
Riprendendo la convenzione sui nomi di package descritta nella sessione precedente creiamo la seguente struttura di package
valida per tutte le classi del progetto:
com.nomeAzienda.progettoCorso
Allinterno del package progettoCorso andiamo a creare un package dove metteremo le classi oggetto del dominio e lo
chiameremo appunto dominio. Quindi avremo:
com.nomeAzienda.progettoCorso.dominio
Allinterno di questo package andremo a creare il file Corso.java contenente la nostra classe:

package com.azienda.esempiCorso.sessione4; //struttura dei packages

public class Corso {

// INIZIO DICHIARAZIONI ATTRIBUTI


private String docente = null;

6
private String [] allievi = null;
private String materia = null;
private String aula = null;
// FINE DICHIARAZIONI ATTRIBUTI

// INIZIO DICHIARAZIONI METODI


public String getDocente() {
return docente;
}
public void setDocente(String docente) {
this.docente = docente;
}
public String[] getAllievi() {
return allievi;
}
public void setAllievi(String[] allievi) {
this.allievi = allievi;
}
public String getMateria() {
return materia;
}
public void setMateria(String materia) {
this.materia = materia;
}
public String getAula() {
return aula;

7
}
public void setAula(String aula) {
this.aula = aula;
}
// FINE DICHIARAZIONI METODI

}
Analizzando il listato precedente nel dettaglio possiamo notare i seguenti elementi:
definizione del package
import di altri package e classi
dichiarazione del nome e del qualificatore di accesso (public) della classe
dichiarazione (e inizializzazione) degli attributi
dichiarazione ed implementazione dei metodi

Definizione del package


E sempre la prima istruzione del codice sorgente della classe. La scelta dei nomi dei package arbitraria, anche se consigliamo
di attenersi alla convenzione che abbiamo descritto nella sessione precedente (dominio web-nomeAzienda-nomeProgetto) per la
radice di tutti i package e di qui in poi usare nomi di sotto-package che siano quanto pi possibile auto-esplicativi: nellesempio
abbiamo usato dominio come nome del package dove andremo a mettere tutte le classi che definiscono il dominio della nostra

8
applicazione. Successivamente potremmo creare un package web dove mettere tutte le classi che riguardano la parte web
dellapplicazione etc.
Il nome del package insieme al nome della classe compone il nome fully-qualified (o nome completo, pienamente qualificato)
della classe. Dal punto di vista della JVM (Java Virtual Machine) il vero nome della nostra classe desempio non soltanto Corso
(che prende il nome di simple-name) ma com.azienda.progettoCorso.Corso.

Import di altri package/classi


La nostra classe pu fare riferimento ad altre classi (fornite dal JDK o create da noi).
Per esempio potremmo aggiungere alla nostra classe Corso un attributo che rappresenti la data di inizio del corso. Per farlo
andremo ad utilizzare una classe fornita dal JDK:
java.util.Date. Si tratta della classe Date presente allinterno del package java.util.
Per aggiungere lattributo, nella sezione di dichiarazione degli attributi potremmo aggiungere:
private java.util.Date dataInizioCorso = null;
In tal caso, abbiamo fatto direttamente riferimento al nome fully-qualified della classe Date, premettendo il nome del package
java.util.
Se per volessimo dichiarare in modo pi snello il tipo Date, usando il simple-name della classe senza package, allora dovremmo
aggiungere subito dopo la clausola package, la clausola import seguita dal nome fully-qualified della classe Date in questo modo:
import java.util.Date;

9
a questo punto la dichiarazione dellattributo dataInizioCorso diventerebbe:
private Date dataInizioCorso
Avremmo anche potuto scrivere listruzione di import in questo modo:
import java.util.*;
Il carattere * (asterisco) istruisce la JVM di importare tutte le classi del package java.util.
A quel punto avremmo potuto utilizzare tutte le classi del package java.util con il loro simple-name.
Il package di base del JDK java.lang. Tutte le classi di questo package sono automaticamente incluse nel codice sorgente di
ogni classe che andremo a scrivere. Di fatti, osservando attentamente il codice si pu notare che abbiamo usato la classe String
senza dichiararne il package. Questo proprio perch String fa parte del package java.lang e pertanto non necessario dichiararne
limport esplicitamente.
Ecco come diventerebbe il codice sorgente della nostra classe Corso dopo laggiunta dellattributo dataInizioCorso (e dei relativi
metodi set e get):
package com.azienda.esempiCorso.sessione4; //struttura dei packages

import java.util.Date; //notare l'import della classe col nome fully-qualified

public class Corso2 {

// INIZIO DICHIARAZIONI ATTRIBUTI


private String docente = null;

10
private String [] allievi = null;
private String materia = null;
private String aula = null;
private Date dataInizioCorso = null; //nuovo attributo
// FINE DICHIARAZIONI ATTRIBUTI

// INIZIO DICHIARAZIONI METODI


public String getDocente() {
return docente;
}
public void setDocente(String docente) {
this.docente = docente;
}
public String[] getAllievi() {
return allievi;
}
public void setAllievi(String[] allievi) {
this.allievi = allievi;
}
public String getMateria() {
return materia;
}
public void setMateria(String materia) {
this.materia = materia;
}
public String getAula() {

11
return aula;
}
public void setAula(String aula) {
this.aula = aula;
}
public Date getDataInizioCorso() {
return dataInizioCorso;
}
public void setDataInizioCorso(Date dataInizioCorso) {
this.dataInizioCorso = dataInizioCorso;
}
// FINE DICHIARAZIONI METODI

Qualificatori di accesso
I qualificatori di accesso determinano i privilegi di accesso ad una variabile/oggetto/metodo.
Determinano quindi quali parti di codice possono accedere alla variabile/oggetto/metodo a cui si riferiscono.
Si tratta di un elemento molto importante del linguaggio Java che abbiamo gi introdotto nella sessione precedente e che
riprenderemo anche pi avanti.
Di fatti per comprenderli appieno occorrono altri elementi del linguaggio Java che verranno introdotti successivamente (come
leredirariet).

12
Seguiremo comunque la stessa metodologia che intendiamo usare per tutto il corso: introdurre i concetti un po alla volta, in
maniera progressiva anche attraverso esempi pratici.
Il significato preciso dei qualificatoti, infatti, dipende da una moltitudine di fattori (tra cui anche lelemento a cui vengono
applicati, se classe, attributo, metodo etc.) che non vogliamo introdurre tutti in una volta per non appesantire troppo la trattazione.
Solo al livello introduttivo possiamo iniziare a dire che i qualificatori sono:
public: accessibilit completa
private: accessibilit ristretta solo ai membri (attributi o metodi) della stessa classe
protected: accessibilit ristretta solo ai membri della classe e delle classi derivate (concetto che vedremo pi avanti)
vuoto, ovvero omesso (default): quando il qualificatore viene omesso, la JVM utilizza il default che permette
laccesso solo allinterno delle classi dello stesso package della classe in cui definito lo specificatore
Dichiarazione del nome e del qualificatore di accesso della classe
Tornando alla dichiarazione della classe, analizzando il listato, dopo la definizione del package e degli eventuali import, troviamo
la dichiarazione:
public class Corso
Distinguiamo 3 elementi:
qualificatore di accesso (public)
parola chiave class

13
nome della classe Corso
Il qualificatore public, nel caso di una classe, indica che questultima utilizzabile nel codice di qualunque altre classe. public
rappresenta la quasi totalit dei casi nelle dichiarazioni di una classe. Tuttavia possibile anche che una classe sia dichiarata
private o protected o senza specificatore di accesso (default). Una classe definita come private o protected o senza specificatore
deve comunque essere sempre presente allinterno di una dichiarazione di una classe public. In questi ultimi casi si parla infatti di
classi inner (interne).

Dichiarazione (e inizializzazione) degli attributi


Continuando lanalisi del listato di dichiarazione della classe Corso, troviamo la sezione di dichiarazione degli attributi della
classe:
// INIZIO DICHIARAZIONI ATTRIBUTI
private String docente = null;
private String [] allievi = null;
private String materia = null;
private String aula = null;
private Date dataInizioCorso = null; //nuovo attributo
// FINE DICHIARAZIONI ATTRIBUTI
La dichiarazione segue le regole gi viste nella sessione precedente riguardo la dichiarazione delle variabili.

14
E buona norma, ma non obbligatorio, inizializzare gli attributi gi in fase di dichiarazione. Nel nostro caso, avendo tutti attributi
di tipo classe (come detto String una classe del package java.lang), linizializzazione che usiamo quella di default impostando
a null il valore degli attributi.

Il qualificatore di accesso va interpretato per gli attributi della classe, a grandi linee, nel seguente modo:
public: lattributo accessibile in qualunque blocco di codice anche esterno alla classe Corso
private: lattributo accessibile soltanto allinterno della classe Corso
protected: lattributo accessibile allinterno della classe Corso ed allinterno delle classi che ereditano dalla nostra classe
Corso (vedere pi avanti)
nessun valore (default): lattributo accessibile solo allinterno della classe Corso ed allinterno delle altre classi che fanno
parte dello stesso package (com.azienda.progettoCorso.dominio nel nostro caso)

Dichiarazione ed implementazioni dei metodi


La dichiarazione o firma di un metodo cos composta:
qualificatoreAccesso tipoRitorno nomeMetodo(parametri metodo)
Ad esempio, analizziamo dal listato il seguente metodo:

public String getDocente() {

15
return docente;
}

Per quanto riguarda il metodo getDocente, la firma :


public String getDocente()
ovvero stiamo dichiarando che:
o public, quindi accessibile in qualunque altra parte del codice (anche allesterno della classe Corso)
o il metodo deve ritornare un valore di tipo String (parametro di output del metodo). Ovvero il codice del metodo deve
terminare con unistruzione return che restituisca al chiamante un valore di tipo String
o il nome del metodo getDocente
o (): il metodo non ha parametri di ingresso. Le parentesi tonde sono infatti vuote
Dopo la firma del metodo segue il corpo del metodo delimitato come al solito dalle parentesi graffe:
return docente;
Il metodo esegue una sola istruzione: restituisce il valore dellattributo docente.
Da notare che pur essendo lattributo docente dichiarato come private esso risulta comunque accessibile al metodo getDocente()
poich il metodo e lattributo appartengono alla stessa classe Corso.
Adesso passiamo ad analizzare il metodo setDocente:

public void setDocente(String docente) {

16
this.docente = docente;
}

Di nuovo rispetto al metodo precedentemente analizzato, getDocente(), possiamo notare:


o il tipo di ritorno del metodo void. Questa la parola chiave utilizzata in Java per indicare che il metodo non ritorna
nulla (il metodo infatti serve per impostare un nuovo valore per la variabile docente, ma non deve restituire nulla)
o il metodo possiede un parametro di ingresso (o di input): String docente (indicato tra le parentesi tonde dopo il nome
del metodo)
o il corpo del metodo imposta il valore dellattributo docente assegnandogli il valore del parametro di ingresso. Da
notare che il parametro di ingresso si chiama anchesso docente. Per risolvere il conflitto di nomi tra lattributo della
classe docente ed il parametro di ingresso del metodo docente viene utilizzata la parola chiave this. Di questa parola
chiave ne riparleremo, per adesso sufficiente capire che in questo caso serve per referenziare gli attributi o i metodi
della classe nel codice scritto allinterno della classe stessa (in pratica this un riferimento alla classe stessa
allinterno della quale stiamo scrivendo il codice)

Parola chiave final


La parola chiave final pu essere utilizzata nella definizione di attributi, metodi e classi

17
o applicata ad un attributo: indica che lattributo, dopo essere stato inizializzato, non pi modificabile. Come visto
anche nella sessione introduttiva, viene usata per definire delle costanti. Generalmente, come convenzione, in Java
nella definizione delle costanti si usano solo lettere maiuscole
Esempio:

package com.azienda.esempiCorso.sessione4;

public class FinalExample {

private final String NAZIONE = "Italia";

public void modificaNazione()


{
NAZIONE = "FRANCIA"; /* errore -> non si pu modificare l'attributo definito final */
}

Nellesempio viene mostrato un codice che genererebbe un errore in fase di compilazione, in quanto stiamo cercando
di modificare il valore della variabile NAZIONE che stata dichiarata final, dopo averle assegnato un valore iniziale
o applicata ad un metodo: questo sar chiaro pi avanti nel corso quando parleremo di ereditariet; per ora anticipiamo
che un metodo definito in una classe A pu essere modificato da classi figlie di A (classi che ereditano da A); nel
senso che le classi figlie di A possono modificare il corpo del metodo, ovvero il codice eseguito quando il metodo

18
viene invocato. Quando si inserisce la parola chiave final nella firma del metodo, si impedisce questa possibilit: il
corpo del metodo non potr pi essere modificato da nessuna classe. Vedremo un esempio quando parleremo di
ereditariet
o applicata ad una classe: anche questo caso sar chiaro solo dopo aver parlato di ereditariet. Per ora anticipiamo che
in Java una qualunque classe pu essere ereditata, ovvero data una classe A potremo sempre scrivere in seguito una
classe B che eredita da A; a meno che non dichiariamo la classe A come final: in questo caso la classe A non pu
avere classi figlie. Vedremo un esempio quando parleremo di ereditariet

Parola chiave static


La parola chiave static applicabile nella definizione di un attributo, di un metodo o di una classe:
o static applicata ad un attributo: quando si definisce una classe A, tutti gli oggetti di classe A che andremo ad
istanziare nel nostro codice hanno una propria copia degli attributi e dei metodi della classe A. Viceversa, se
definiamo un attributo come static, stiamo dicendo che il valore di questattributo condiviso tra tutti gli oggetti che
andremo a creare di classe A. Il modo di accedere ad un attributo static differente rispetto ad un attributo non
dichiarato static.
Come abbiamo gi visto, per accedere ad un attributo non statico della classe A, dobbiamo prima istanziare un
oggetto di classe A (tramite listruzione new) e successivamente accedere (se i modificatori di accesso ce lo
consentono, quindi se lattributo public) tramite dotted-notation con la sintassi oggetto.nomeAttributo. Invece, per

19
accedere ad un attributo static della classe A non avremo bisogno di usare un oggetto (proprio perch tutti gli oggetti
della classe A condividono la stessa copia dellattributo) ma useremo la sintassi nomeClasse.nomeAttributo,
ovvero A.nomeAttributo.
Per esempio:

package com.azienda.esempiCorso.sessione4;

public class StaticExample {

public static int numeroStatico = 0;


public int numero = 0;
}

package com.azienda.esempiCorso.sessione4;

public class UsoStaticExample {

public static void main(String[] args)


{
StaticExample oggetto1 = new StaticExample();
StaticExample oggetto2 = new StaticExample();
oggetto1.numero = 10;
oggetto2.numero = 20;

20
System.out.println("Oggetto 1.numero (non static): " + oggetto1.numero);
System.out.println("Oggetto 2.numero (non static): " + oggetto2.numero);
oggetto1.numeroStatico = 30;
oggetto2.numeroStatico = 40;
System.out.println("Oggetto 1.numeroStatico: " + oggetto1.numeroStatico);
System.out.println("Oggetto 2.numeroStatico: " + oggetto2.numeroStatico);
}
}
Loutput a video :
Oggetto 1.numero (non static): 10
Oggetto 2.numero (non static): 20
Oggetto 1.numeroStatico: 40
Oggetto 2.numeroStatico: 40

o static applicata ad un metodo: linterpretazione della parola chiave static applicata ad un metodo indica che il
metodo condiviso tra tutte le istanze della classe e pertanto, come per lattributo static, accessibile utilizzando
direttamente il nome della classe e non necessita di un oggetto istanziato. La sintassi sar quindi
nomeClasse.nomeMetodo

21
Parole chiave transient e volatile
transient e volatile sono due parole chiave applicabili nella definizioni degli attributi, poco usate, il cui significato al momento
non pu essere molto chiaro in quanto fanno riferimento a concetti che non sono stati ancora trattati e che comunque saranno
trattati marginalmente in questo corso. Possiamo comunque dire che transient indica che un attributo non serializzabile. In Java
quando un oggetto deve essere trasferito, ad esempio per essere inviato in rete, si dice che loggetto deve essere serializzato,
ovvero deve essere trasformato in una sequenza di byte opportunamente codificata che possa essere inviata ad esempio
remotamente, dove unaltra classe sar in grado di de-serializzarlo, ovvero ricostruire loggetto decodificando la sequenza di byte
serializzata. Un attributo dichiarato transient non serializzabile e quindi non entra in questo meccanismo di serializzazione
appena descritto.
volatile, invece, fa riferimento allutilizzo di attributi allinterno di threads nella programmazione concorrente e non oggetto di
questo corso. Possiamo comunque dire, a titolo informativo, che nella programmazione multi-thread, un processo java pu creare
pi thread (o sotto-processi) che cooperano tra di loro. Ciascun thread generalmente usa una cache locale delle variabili, ovvero
unarea di memoria privata del thread in cui vengono memorizzate queste variabili locali. Quando una variabile definita
transient stiamo stabilendo che tale variabile non deve essere messa in cache dai thread. Ovvero tutti i thread condivideranno la
stessa copia della variabile.

22
Creazione di un oggetto
Per poter utilizzare una classe, come ad es. la nostra classe Corso, in altre parti del nostro codice (ad esempio in altre classi che
andremo a definire), la prima cosa da fare dichiarare una variabile di tipo Corso e inizializzare tale variabile (lo stesso concetto
che abbiamo visto anche per la creazione e lassegnazione di valore ad una variabile di tipo primitivo).
La dichiarazione di una variabile di tipo Corso avviene semplicemente con listruzione
private Corso oggettoCorso;
La creazione, o istanziazione di un oggetto, loperazione che viene effettuata per creare lo spazio in memoria necessario per
ospitare loggetto. Loggetto creato viene definito unistanza della classe a cui appartiene.
La parola chiave necessaria per costruire un oggetto new:
private Corso oggettoCorso = new Corso();

Adesso la variabile oggettoCorso un oggetto o istanza di classe Corso pronta per essere utilizzata.

Tecnicamente, la JVM per costruire un oggetto di una determinata classe, invoca un particolare metodo della classe detto
costruttore.

23
Tutte le classi Java hanno un costruttore e quando non viene esplicitamente definito dal programmatore la JVM usa un
costruttore di default.

Il costruttore di default un metodo senza parametri che inizializza loggetto/istanza impostando tutti i suoi attributi al loro
valore di default.

Se guardiamo il listato del nostro codice sorgente della classe Corso non vediamo alcun costruttore. Questo vuol dire che se noi
creassimo unistanza di classe Corso tramite listruzione:

private Corso oggettoCorso = new Corso();

la JVM invocherebbe il costruttore di default che inizializzerebbe tutti i nostri attributi al loro valore di default. Ma, come detto
prima, essendo gli attributi della classe Corso, tutti di tipo classe (tutte stringhe o array di stringhe) il loro valore iniziale di
default null. Ma, a ben, vedere nel nostro codice noi abbiamo gi inizializzato tutti i nostri attributi a null nella fase di
dichiarazione degli attributi. Pertanto, nel nostro, esempio il costruttore di default della JVM non farebbe nulla di diverso rispetto
a quanto abbiamo gi fatto noi.

La sintassi di Java per la definizione del metodo costruttore di una classe :

24
public Corso() {
docente = "Mario Rossi";
allievi = new String[20];
allievi[0] = "Carlo Bianchi";
}

Ovvero, occorre definire nellordine:

o specificatore di accesso (quasi sempre sar public)


o nome del costruttore che deve essere uguale al nome della classe
o eventuali parametri del costruttore
o corpo del costruttore, ovvero codice che deve essere eseguito quando la JVM invoca il costruttore

Come si pu notare, il costruttore, a differenza degli altri metodi, non ha un tipo di ritorno. Questo perch implicitamente
definito che il tipo di ritorno deve essere la classe a cui appartiene il costruttore.

Nellesempio mostrato prima abbiamo quindi definito un costruttore vuoto, ovvero senza parametri, il cui corpo provvede a sua
volta a:

25
o impostare il docente col nome Mario Rossi
o istanziare lattributo allievi come array di stringhe di dimensione 10
o assegnare al primo elemento dellarray allievi, ovvero allievi[0], il valore Carlo Bianchi

Con questo nuovo costruttore, leffetto dellistanziazione di un oggetto tramite listruzione

private Corso oggettoCorso = new Corso();

differente rispetto a quanto visto prima, quando non avevamo definito nessun costruttore (e quindi veniva usato quello di
default). Col costruttore di default leffetto dellistruzione di creazione era quello di istanziare loggetto oggettoCorso con
allinterno tutti gli attributi a null. Anche larray allievi era quindi un oggetto null (quindi non ancora utilizzabile).

Con la nuova versione del costruttore, invece, al termine dellistruzione di istanziazione nelloggetto oggettoCorso troveremo gi
impostati due attributi.

Ecco un altro esempio di costruttore della classe Corso, questa volta con due parametri di ingresso:

26
public Corso(String docente,String materia)
{
this.docente = docente;
this.materia = materia;
}

In questo caso il costruttore provvede ad impostare gli attributi docente e materia con i valori dei parametri di ingresso del
metodo (notare ancora una volta luso di this per evitare il conflitto di nomi).

Se, in fase di istanziazione di un oggetto di classe Corso, vogliamo usare il costruttore con 2 parametri la sintassi sar
leggermente diversa:

private Corso oggettoCorso = new Corso(Mario Rossi,Java);

e nulla ci impedisce di usare entrambe le versioni del costruttore. Attenzione per al fatto che quando definiamo un
costruttore con parametri, la JVM rimuove il costruttore di default, e pertanto linvocazione del costruttore senza parametri
tramite listruzione Corso oggettoCorso = new Corso() ammessa soltanto se lasciamo il costruttore vuoto (senza parametri)
esplicitamente definito da noi. In altre parole, nellesempio precedente, se rimuovessimo il costruttore vuoto e lasciassimo quello
con 2 parametri non potremmo pi istanziare un oggetto con listruzione Corso oggettoCorso = new Corso(); ma solo con
listruzione Corso oggettoCorso = new Corso(A,B);.

27
Lasciando invece entrambe le versioni dei costruttori potremmo istanziare due oggetti che usano le due versioni del costruttore:

private Corso oggettoCorso = new Corso(Gianni Verdi,Inglese);

private Corso oggettoCorso2 = new Corso();

Nellesempio appena visto, oggettoCorso sar inizializzato col costruttore senza parametri e quindi avr gli attributi docente =
Mario Rossi e materia = Java, mentre loggetto oggettoCorso2 sar inizializzato col costruttore con due parametri e
pertanto al termine della costruzione avr gli attributi docente = Gianni Verdi e materia = Inglese.

Lutilizzo delle due forme di costruttori ci permette di introdurre un concetto tipico della programmazione object oriented:
loverloading di metodi.

Si parla di overloading di metodi quando esistono nella stessa classe (o nelle sue classi derivate come vedremo quando parleremo
di ereditariet) metodi che hanno lo stesso nome ma un differente numero di parametri. Nellesempio visto abbiamo un
costruttore overloaded, senza parametri e con due parametri, ma la stessa tecnica pu essere applicata a qualunque metodo di
una classe.

28
Utilizzo di oggetti
Dopo che un oggetto stato istanziato possibile iniziare ad utilizzarlo.

Si pu quindi accedere (se i qualificatori di accesso lo consentono) ed operare sugli attributi e/o sui metodi delloggetto.

Per accedere ai membri (attributi e metodi) di un oggetto si usa la cosiddetta dotted notation (notazione con punto), ovvero il
nome delloggetto seguito dal carattere . (punto) e quindi dal nome del membro.

Ad esempio, in unaltra classe del nostro progetto potremmo scrivere le seguenti righe di codice:

private Corso oggettoCorso = new Corso();

oggettoCorso.docente = Paolo Gialli;

oggettoCorso.setDocente(Paolo Gialli);

String s = oggettoCorso.getDocente();

Sytem.out.println(Il nome del docente : + s);

29
In base a quanto detto a proposito dei qualificatori di accesso, possiamo notare che nel listato precedente listruzione
oggettoCorso.docente andrebbe in errore perch lattributo docente dichiarato private per la classe Corso e stiamo
provando ad accederci dallesterno della classe. Viceversa, listruzione oggettoCorso.setDocente(Paolo Gialli);
corretta, essendo il metodo setDocente dichiarato public.

Eliminando lerrore dellistruzione oggettoCorso.docente = . possiamo descrivere il listato di codice precedente in questo
modo:

viene istanziato loggetto oggettoCorso


viene impostato il valore dellattributo docente delloggetto oggettoCorso attraverso linvocazione del metodo setDocente
con il valore stringa Paolo Gialli
viene definita una variabile s di tipo String
viene assegnata alla variabile s il valore dellattributo docente delloggetto oggettoCorso attraverso linvocazione del
metodo getDocente()
viene stampato a video la stringa Il nome del docente : Paolo Gialli attraverso listruzione System.out.println

30
Terminiamo questa prima parte sulla definizione degli oggetti specificando il concetto di stato di un oggetto.

Lo stato di un oggetto rappresentato dal valore che assumono (in un determinato momento) gli attributi delloggetto.
Un oggetto di classe Corso, in un determinato momento, potrebbe avere uno stato rappresentato da:
o docente = Mario Rossi
o allievi = [Carlo Verdi,Francesco Bianchi]
o materia = Java
o aula = Aula T2

In un altro momento, tramite chiamate ai metodi setDocente, setMateria, setAllievi, setAula potremmo cambiare lo stato
delloggetto andando a reimpostare i valori degli attributi delloggetto.

31