Post
Campi di esemplare
§ Un oggetto memorizza i propri dati all’interno di campi (o
variabili) di
esemplare (o
di istanza)
§ Campo è
un termine tecnico che identifica una posizione all’interno di
un blocco di memoria
§ Un esemplare
(o istanza) di una classe è un oggetto creato
da quella
classe.
§ La dichiarazione della classe specifica i suoi campi di
esemplare:
public class BankAccount
{
. . .
private double balance;
}
Campi di esemplare
§ La dichiarazione di un campo di esemplare è così
composta:
§ Uno specificatore
d’accesso (solitamente private)
§ Il tipo
del campo di esemplare (come double)
§ Il nome del campo di esemplare (come balance)
§ Ciascun oggetto di una classe ha il proprio insieme
di campi di esemplare.
§ I campi di esemplare sono generalmente dichiarati
con lo
specificatore di accesso private
Campi di esemplare
Campi di esemplare
Campi di esemplare
Sintassi 3.4:
Dichiarazione di campo di esemplare
specificatoreDiAccesso class NomeClasse
{
specificatoreDiAccesso
tipoVariabile nomeVariabile;
. . .
{
Esempio:
public class BankAccount
{
private double balance;
}
Obiettivo:
Definire un campo che sia presente in ciascun oggetto di una classe.
Accedere ai campi di esemplare
§ I campi di esemplare sono generalmente dichiarati con lo
specificatore di accesso private: a essi si può
accedere soltanto da metodi della medesima classe e da
nessun altro metodo.
§ Se i campi di esemplare vengono dichiarati privati, ogni
accesso ai dati deve avvenire tramite metodi pubblici.
§ L’incapsulamento prevede l’occultamento dei dati degli
oggetti, fornendo metodi per accedervi.
Accedere ai campi di esemplare
§ Ad esempio, alla variabile balance si può accedere dal
metodo deposit della classe BankAccount, ma non dal
metodo main di un’altra classe.
public class BankRobber
{
public static void
main(String[] args)
{
BankAccount momsSavings = new
BankAccount(1000);
. . .
momsSavings.balance = -1000;
// ERRORE
}
}
Realizzare i costruttori
§ Un costruttore assegna un valore iniziale ai campi di
esemplare di un oggetto.
public BankAccount()
{
balance = 0;
}
public BankAccount(double
initialBalance)
{
balance = initialBalance;
}
Esempio di invocazione di un costruttore
BankAccount harrysChecking = new BankAccount(1000);
§ Creazione di un nuovo oggetto di tipo BankAccount.
§ Invocazione del secondo costruttore (perché è stato
fornito un
parametro di costruzione).
§ Assegnazione del valore 1000 alla variabile parametro
initialBalance.
§ Assegnazione del valore di initialBalance al campo di
esemplare
balance dell’oggetto appena creato.
§ Restituzione, come valore dell’espressione new, di un
riferimento a un
oggetto, che è la posizione in memoria dell’oggetto appena creato.
§ Memorizzazione del riferimento all’oggetto nella variabile
harrysChecking.
Realizzare metodi
§ Alcuni metodi non restituiscono un valore
§ Alcuni metodi restituiscono un valore
public void withdraw(double amount)
{
double newBalance = balance -
amount;
balance = newBalance;
}
public double getBalance()
{
return balance;
}
Esempio di una invocazione di metodo
§ Assegnazione del valore 500 alla variabile parametro amount.
§ Lettura del campo balance dell’oggetto che si trova nella
posizione
memorizzata nella variabile harrysChecking.
§ Addizione tra il valore di amount e il valore di balance,
memorizzando il risultato nella variabile newBalance.
§ Memorizzazione del valore di newBalance nel
campo di esemplare
balance, sovrascrivendo il vecchio valore.
harrysChecking.deposit(500);
Sintassi 3.5: L'enunciato return
return espressione;
oppure
return;
Esempio:
return balance;
Obiettivo:
Specificare il valore restituito da un metodo e
terminare l’esecuzione
del metodo immediatamente. Il valore restituito diventa
il valore
dell’espressione di invocazione del metodo.
File BankAccount.java
01: /**
02: Un conto bancario ha un saldo che
può essere modificato
03: da depositi e prelievi.
04: */
05: public class BankAccount
06: {
07: /**
08: Costruisce un conto bancario con
saldo uguale a zero.
09: */
10: public BankAccount()
11: {
12: balance = 0;
13: }
14:
15: /**
16: Costruisce un conto bancario con un saldo assegnato.
17: @param initialBalance il saldo iniziale
18:
*/
19: public
BankAccount(double initialBalance)
20: {
21: balance =
initialBalance;
22: }
23:
24: /**
25: Versa denaro nel conto bancario.
26: @param amount l'importo da versare
27: */
28: public void
deposit(double amount)
29: {
30: double newBalance
= balance + amount;
31: balance =
newBalance;
32: }
33:
34: /**
35: Preleva denaro dal conto bancario.
36:
@param amount l'importo da versare
37: */
38: public void
withdraw(double amount)
39: {
40: double newBalance
= balance - amount;
41: balance =
newBalance;
42: }
43:
44: /**
45: Ispeziona il valore del saldo attuale del conto bancario.
46: @return il saldo
attuale
47: */
48: public double
getBalance()
49: {
50: return balance;
51: }
52:
53: private double balance;
54:
}
Collaudare una classe
§ Collaudo di unità: verifica che la classe a sè stante funzioni
correttamente, al di fuori di un programma completo
§ Per collaudare una classe usate un ambiente per il
collaudo interattivo oppure scrivete un’altra classe che
esegua istruzioni di collaudo
§ Classe di test: una classe con un metodo main che
contiene gli enunciati che servono al collaudo di un’altra
classe.
§ Esegue solitamente i passi seguenti:
1. Costruzione di uno o più oggetti
della classe che si sta collaudando.
2. Invocazione di uno o più metodi.
3. Visualizzazione di uno o più
risultati.
4. Visualizzazione dei risultati
previsti.
Collaudare una classe
§ I dettagli per costruire un programma dipendono dal
vostro compilatore e dall’ambiente di sviluppo; nella
maggior parte degli ambienti, dovrete eseguire questi
passi:
1. Creare una nuova cartella per il
vostro programma.
2. Creare due file, uno per ciascuna
classe.
3. Compilare entrambi i file.
4. Eseguire il programma di collaudo.
File BankAccountTester.java
01: /**
02: Classe di collaudo per la classe BankAccount.
03: */
04: public class BankAccountTester
05: {
06: /**
07: Collauda i metodi della classe BankAccount.
08:
@param args non utilizzato
09: */
10: public static void
main(String[] args)
11: {
12: BankAccount
harrysChecking = new BankAccount();
13: harrysChecking.deposit(2000);
14: harrysChecking.withdraw(500);
15: System.out.println(harrysChecking.getBalance());
16: } // ++++
17:
}
Errori comuni
§ Un costruttore non restituisce alcun tipo (neanche void)
– public void BankAccount() {…}
è un metodo che si chiama BankAccount e restituisce void
– public BankAccount() {…}
è un costruttore per la classe BankAccount
– Non
usare “return” nei costruttori!
Nessun commento:
Posta un commento