Classi e oggetti
Possono:
- Modellare gli oggetti del mondo reale
- Rappresentare oggetti grafici
- Rappresentare entitĂ software
- Rappresentare concetti astratti (regole di un gioco)
- Rappresentare stati di un processo, di esecuzione, ecc.
Cos’è una classe?
- è un pezzo del codice sorgente di un programma
- vengono definite dal programmatore
- fornisce un prototipo astratto per gli oggetti di un particolare tipo
- Ne definisce la struttura in termini di
- Campi (stato) degli oggetti
- Metodi (comportamenti) degli oggetti
Cos’è un oggetto?
- è un’istanza (un esemplare) di una classe
- Un programma può creare e usare uno o più oggetti (istanze) della stessa classe
Example
Classe
- Specifica la struttura (ovvero numero e tipi) dei campi dei suoi oggetti
- Specifica il comportamento dei suoi oggetti mediante il codice dei metodi
Oggetto:
- Contiene specifici valori dei campi; i valori possono cambiare durante l’esecuzione (a runtime)
- Creato quando un programma “gira” (dal metodo main o da un altro metodo) (a runtime)
Esempio Sonic
Classi e file sorgenti
- Ogni classe è memorizzata in file separato
- Il nome del file deve essere lo stesso della classe, con estensione .java
- I nomi di classe iniziano sempre con una maiuscola
- I nomi in java sono case-sensitive
Librerie
I programmi java solitamente non sono scritte da zero
(parti del java environment)
- Esistono migliaia di librerie scritte per ogni esigenza
- Le classi sono sviluppare pin package
- java.util - classi di unitĂ
- java.awt - classi per la grafica e le finestre
- java.swing e javafx – sviluppo di interfacce GUI
- Un package “speciale” è java.lang: contiene le classi fondamentali per la programmazione in Java (es. String, System, ecc.)
Struttura di un codice in Java
Esercizio (Counter.java)
- Realizzare una classe che rappresenta un contatore
- Il contatore permette di:
- Incrementare il conteggio attuale
- Ottenere in conteggio attuale
- Resettare il conteggio a 0 o a un altro valore
public class Counter
{
//valore intero del contatore
private int value; //Dichiarazione di un campo, in questo caso è privato
//costruttore della classe
public Counter () //Costruttore degli oggetti della classe
{
value=0; //inizializza il campo value
}
//incrementa il contatore
public void count() //void: non restituisce nulla
{
value++; //incrementa il valore di value
}
// ottiene il valore corrente del contatore @return valore intero del contatore
public int getValue() {return value;} //restituisce il valore value
}Campi (o variabile di istanza)
- costituisce la memoria privata di un oggetto
- Ogni campo ha un tipo di dati (ex. il valore del contatore è intero)
- Ogni campo ha un nome fornito dal programmatore (ex. value nell’esempio counter.java)
Dichiarazione di un campo
private [static] [final] tipo_di1_dati nome;[static]se specificato indica che il campo è condiviso da tutti (caratterizza tutti gli oggetti istanza della classe)[final]Se specificato indica che il campo è una costante- L’unico metodo di cui non bisogna specificare il tipo è il costruttore
Esempio di dichiarazione
public class Hotel
{
//Da evitare l'uso di una variabile di "comodo" come campo di una classe
private int k;
private String nome;
p
}
Metodi
- è tipicamente pubblico, ovvero visibile a tutti
- Il nome di un metodo per convenzione inizia con una lettera minuscola, mentre le parole seguenti iniziano con lettera maiuscola
- Convenzione detta Camel Case
Definizione di un metodo
public tipo_di_dati nomeDelMetodo (tipo_di_dati nomePar1,.., tipo_di_dati nomPar)
{
istruzione 1;
.
. // corpo del metodo
.
instruzione m;
}- Tipo del valore restituito (void se non viene restituito nulla)
- Elenco (eventualmente vuoto) dei nomi di parametri con relativo tipo
Example
public int getValue() { return value; }
public void reset (int newValue) { value= newValue; }- Un metodo può restituire un valore al chiamante
- La parola chiave void nell’intestaione (“signature” o “header”) del metodo indica che il metodo non restituisce alcun valore
Costruttori
- Metodi (funzioni) per la creazione degli oggetti di una classe
- Possiedono sempre lo stesso nome della classe
- Inizializzano i campi dell’oggetto
- Possono prendere zero, uno o piĂą parametri
- Non hanno valori in uscita (ma non specificano void)
- Una classe può avere anche più costruttori che differiscono nel numero e nei tipi dei parametri (overloading)
Example (counter)
// costruttore della classa
public Counter()
{
value=0;
}
//costruttore della classe con valore iniziale
public Counter (int initialValue) //input del costruttore
{
value = initialValue;
}Creazione dell’oggetto
static public void main (String[] args)
{
Counter contatore 1 = new Counter(); //new: nuova istanza
Counter contatore 2 = new Counter (42);
System.out.println("Valore del contatore1: "+contaore1.getValue());
System.out.println("Valore del contatore2: "+contaore2.getValue());
//Costruttore della classe con valore iniziale
public Counter(int initialValue)
{
value = initialValue;
}
}- Il numero, l’ordine e i tipi dei parametri devono corrispondere
- Il main deve essere in un file che ha dei collegamenti con la classe Count
- Se le classi sono in package diversi bisogna importarle
Costruttori
- Non è obbligatorio specificare un costruttore
- Se non ne viene specificato uno, Java crea per ogni classe un costruttore di default “vuoto” (senza parametri)
- Inizializza le variabili d’istanza ai valori di default
Implementazione del metodo reset
Versione 1
Azzera il contatore
public void reset() { value= 0;}Versione 2
Reimposta il contatore a un determinato valore
public void reset(int newValue) { value = newValue;}Chiamate di metodi
- Overloading
static public void main (String[] args)
{
Counter contatore1 = new Counter();
Counter contatore2 = new Counter(42);
contatore1.count();
contatore2.count();
contatore2.reset();
contatore1.reset(10);
System.out.println("Valore del contatore1: " +contatore1.getValue());
System.out.println("Valore del contatore2: " +contatore2.getValue());
}Variabili locali e campi
-
I campi sono variabili dell’oggetto
- Sono visibili almeno all’interno di tutti gli oggetti della stessa classe
- Esistono per tutta la vita di un oggetto
-
Le variabili locali sono variabili definite all’interno di un metodo
- Come parametri del metodo o all’interno del corpo del metodo
- Esistono dal momento in cui sono definite fino al termine dell’esecuzione della chiamata al metodo in questione
Incapsulamento
Perché utilizzare le parole chiave public e private?
- Per nascondere le informazioni (“information hiding”) all’utente
- Il processo che nasconde i dettagli realizzativi, rendendo privata un’interfaccia, prende il nome di incapsulamento
- Dettagli realizzatovi: campi e implementazione
- Interfaccia pubblica: metodi pubblici
Perché incapsulare?
- Si semplifica e modularizza il lavoro di sviluppo assumendo un certo funzionamento a “scatola nera”
- Non è necessario sapere tutto, soprattutto molti inutili dettagli
- L’incapsuclamento facilita il lavoro di gruppo e l’aggiornameto del codice (maintenance)
- Aiuta a rilevare errori: in presenza di moltissime classi, un ceto errore si verifica solo ina determinata classe per cui si può concentrare su di essa
Come interagiscono le classi tra di loro?
- Una classe interagisce con le altre principalmente (=quasi solo) attraverso i costruttori e i metodi pubblici
- Le altre classi non devono conoscere i dettagli implementativi di una classe per usarla in modo efficace
Accesso a campi e metodi (inclusi i costruttori)
- I campi e i metodi possono essere pubblici, privati (o protetti)
- I metodi di una classe possono chiamare i metodi pubblici e privati della stessa classe
- I metodi di una classe possono chiamare i metodi pubblici (ma non quelli privati) di altre classi
UML: i diagrammi delle classi
UML
è un linguaggio di modellazione e di specifica basato sul paradigma orientato agli oggetti
Example: realizzare un menĂą
Realizzare la classe Menu in grado di visualizzare:
- Inizia il gioco
- Carica il gioco
- Aiuto
- Esci
Fase 1: Identificare i metodi richiesti
- Aggiungere una nuova opzione
- Visualizzare il menĂą
Fase 2: Specificare l’interfaccia pubblica
- Aggiungere una nuova opzione:
public void addOption (String option {}
- Visualizzare il menĂą
public void display() {}
- Costruire l’ggetto
- Costruttore on una prima opzioni in input?
- Costruttore vuoto?
- Meglio evitare casi speciali
public Menu() {}
Fase 3: Scrivere la documentazione per l’interfaccia pubblica
public class Menu
{
public Menu
{
}
public void addOption (String option)
{
}
public void display()
{
}
}Fase 4: Identificare i campi
- In ogni momento, qual è lo stato di un oggetto di tipo Menu?
public class Menu
{
private String menuText;
private int optionCount;
}Fase 5: Implementare i metodi
public class Menu
{
public Menu
{
menuText = "";
optionCount = 0;
}
public void addOption (String option)
{
System.out.println(menuText);
}
public void display()
{
optionCount++;
menuText += optionCount ") " + option + "\n";
}
}Fase 6: Collaudare la classe
public class MenuTest
{
static public void main (String [] args)
{
Menu menu = new Menu();
menu.addOption ("Open new account");
menu.addOption ("Log intp existing account");
menu.addOption ("Help");
menu.addOption ("Quit");
menu.display();
}
}