Progettare una classe 21 Febbraio 2006

La classe BankAccount Vogliamo realizzare una classe i cui oggetti sono dei semplici conti bancari. * Identifichiamo lo stato interno di un conto. * Definiamo le variabili d'istanza corrispondenti. Identifichiamo le operazioni fondamentali che si fanno su di un conto. * Definiamo i metodi che realizzano queste operazioni.

Stato e variabili di istanza Per semplicità, consideriamo che un conto abbia nel suo stato solo un valore di tipo double, che memorizza il saldo attuale del conto. private double balance; In un esempio più realistico, nello stato sarà memorizzato il titolare del conto, le condizioni applicate, i movimenti... Nota: la variabile è dichiarata "private", cioè accessibile e visibile solo all'interno della classe in cui è dichiarata.

Come si dichiara una variabile d'istanza? All’interno della classe, specificandone anche la visibilità. Sintassi: ; = ; Esempi: private double balance; private double balance = 0;

Effetto: Ogni oggetto della classe BankAccount ha una propria variabile balance. * determina la visibilità della variabile. * private : la variabile è visibile solo all'interno della classe. * public : è visibile ovunque. Se manca, la variabile è visibile in tutte le classi del package.

Operazioni... Decidiamo di considerare solo le seguenti operazioni su di un conto bancario: depositare denaro, prelevare denaro, chiedere il saldo corrente e metodi corrispondenti deposit (deposita): si aspetta come parametro un valore di tipo double, l'ammontare da depositare. withdraw (preleva): ha un parametro double. getBalance (reperisci il saldo): non ha parametri, e restituisce un double.

public void deposit(double amount){ \\ MODIFIES: this \\ EFFECTS: aggiunge amount dal saldo corrente} public void withdraw(double amount) ){ \\ MODIFIES: this \\ EFFECTS: sottrae amount dal saldo corrente} public double getBalance(){ \\ EFFECTS: restituisce il saldo corrente} Attenzione: si tratta di metodi d'istanza, non statici, come si vede dall'assenza della keyword static. Specifica dei metodi

Come si dichiara un metodo? ( ) { } Esempio: public void deposit(double amount) { balance = balance + amount; } determina la visibilità del metodo (ad es. public, private )

Costruttori All'interno di una classe si possono dichiarare uno o più costruttori per specificare come dovranno essere costruiti i nuovi oggetti a seguito dell'esecuzione della primitiva new. public class BankAccount{ public BankAccount(){ \\EFFECTS: crea un Bankaccount con saldo o... } public BankAccount(double initialBalance){ \\EFFECTS: crea un Bankaccount con saldo initialBalance }.... }

Come si dichiara un costruttore? * il nome deve essere lo stesso della classe * non si specifica un tipo Sintassi: ( ) { }

Overloading Ci possono essere più costruttori in una classe (come in BankAccount ), purché abbiano una diversa lista di parametri (fenomeno di overloading). Il compilatore è in grado di individuare quale sia il costruttore da invocare guardando i parametri. Di solito i costruttori sono usati per inizializzare le variabili, ma in generale possono fare cose ben più complesse. Overloading si puo’ avere anche per gli altri metodi

I costruttori e i metodi di una classe (insieme alle eventuali variabili d'istanza pubbliche) costituiscono l'interfaccia pubblica della classe. Nell'esempio specifico, l'interfaccia è l'insieme delle operazioni alle quali quasiasi parte del codice del programma può accedere per creare e manipolare oggetti di tipo BankAccount. Interfaccia Pubblica (o Specifica)

public class BankAccount{ public BankAccount(){ \\EFFECTS: crea un Bankaccount con saldo o... } public BankAccount(double initialBalance){ \\EFFECTS: crea un Bankaccount con saldo initialBalance } public void deposit(double amount){ \\ MODIFIES: this \\ EFFECTS: aggiunge amount dal saldo corrente} public void withdraw(double amount) ){ \\ MODIFIES: this \\ EFFECTS: sottrae amount dal saldo corrente} public double getBalance(){ \\ EFFECTS: restituisce il saldo corrente} }

Variabili d’istanza La variabile balance non fa parte dell’interfaccia pubblica Chi usa il tipo di dato BankAccount non vede come e’ implementato Vantaggio: l’implementazione del tipo di dato e’ mascherata L'interfaccia pubblica contiene tutte le informazioni per gli utenti del tipo di dato

Esempio: BankAccount mioConto = new BankAccount(); BankAccount tuoConto = new BankAccount(600);... // trasferimento di un importo da un conto ad un altro: double importo = 500; tuoConto.withdraw(importo); mioConto.deposit(importo); Si puo’ scrivere e si deve scrivere guardando solo l’interfaccia pubblica (o specifica)

Implementazione public class BankAccount { private double balance; public BankAccount() { balance = 0; } public BankAccount(double initialBalance) { balance = initialBalance; } implicitamente per default: se non si usa alcuna inizializzazione, le variabili di istanza numeriche vengono poste automaticamente a zero.

Implementazione …………….. public void deposit(double amount) { balance = balance + amount; } public void withdraw(double amount) { double newBalance = balance - amount; if (newBalance >= 0) balance = newBalance; } public double getBalance() { return balance; } }

Si noti che nel corpo dei metodi si possono usare sia i parametri formali ( amount ) che le variabili di istanza ( balance ) ed eventuali variabili locali ( newBalance ). Il riferimento alla variabile d’istanza balance puo’ avere this implicito (si riferisce all’oggetto su cui e’ chiamato il metodo)

Uso del tipo di dato Anche dopo avere visto come viene implementato……. L’utente del tipo di dato non vede le variabili d’istanza (sono private) Bisogna modificare e/o leggere i valori tramite i metodi pubblici

Esempio: BankAccount tuoConto = new BankAccount(600);... // modifica dell’importo double importo = 500; tuoConto.withdraw(importo); // modo corretto tuoConto.balance=balance-importo; // sbagliato!!!!!!!! Non si puo’ accedere alle variabili private (compilatore) Sarebbe in ogni caso metodologicamente sbagliato (per esempio non potrei piu’ garantire che abbia valore positivo)

Valore degli oggetti: riferimento Il valore associato ad una variabile di tipo oggetto e’ il riferimento Di conseguenza le operazioni su variabili di tipo oggetto sono operazioni su riferimenti, non sugli oggetti stessi. Si creano condivisioni tra oggetti con gli assegnamenti ed il passaggio dei parametri

Esempio BankAccount mioConto = new BankAccount(); BankAccount tuoConto = new BankAccount(600); mioconto=tuoConto: //l’oggetto e’ condiviso mioconto.withdraw(600); // tolgo 600 nell’oggetto riferito (chi e’?)

Esercizio Vogliamo modificare BankAccount in modo che Memorizzi anche - il nome del titolare - un codice identificativo del conto (che viene richiesto per poterlo modificare) Vogliamo che gli oggetti abbiano tutti codici diversi

Specifica public class BankAccount{ \\OVERVIEW: Un BankAccount memorizza il nome del titolare \\del conto, il saldo corrente ed il codice \\identificativo (unico) public BankAccount(double initial, String x){ \\ REQUIRES: initial e’ >=0 \\EFFECTS: crea un Bankaccount con saldo initial, \\ nome x e codice identificativo fresh \\(diverso da tutti quelli assegnati in precedenza) } public void deposit(double amount, int x){ \\ MODIFIES: this \\ EFFECTS: aggiunge amount al saldo corrente di this, \\se x e’ il codice corretto}

Specifica public void withdraw(double amount,int x) ){ \\ MODIFIES: this \\EFFECTS: sottrae amount dal saldo corrente di this, \\se x e’ il codice corretto ed il valore e’ positivo} public double getBalance(){ \\EFFECTS: restituisce il saldo corrente di this} public String toString(){ \\EFFECTS: restituisce lo stato di this (nome, saldo, codice)} }

Cosa dovete fare Implementare la classe BankAccount e sviluppare in parallelo il testing Scelta delle variabili (private), i metodi vengono di conseguenza Come garantire che il codice identificativo sia diverso per tutti gli oggetti creati? Usare una variabile statica

Variabili e Metodi statici In una classe possiamo anche dichiarare uno stato e delle funzionalità che sono associati alla classe stessa, e non ai suoi oggetti. Si possono infatti dichiarare: variabili statiche, che costituiscono lo stato della classe; metodi statici, che realizzano le funzionalità della classe. Non appartengono agli oggetti, ma alla classe. Sono di fatto condivisi tra tutti gli oggetti, istanze della classe

Dichiarazione di una classe Lo schema generale di dichiarazione di una classe in Java è il seguente: class { } NOTA: L'ordine delle dichiarazioni all'interno del corpo di una classe non è importante.

Suggerimento public class BankAccount{ private int codice; private String nome; private double amount; private static int proxcodice=0; …………} Le variabili d’istanza descrivono lo stato interno degli oggetti (devono essere inizializzate dal costruttore) La variabile statica appartiene alla classe (condivisa tra tutti gli oggetti) Viene inizializzata al momento della dichiarazione di classe Mantiene il primo codice che ancora non e’ stato usato (va aggiornata)

Tester scelta di casi significativi prelievi, depositi con codici errati, importo non sufficiente usare l’interfaccia pubblica del tipo di dato

public class Tester{ public static void main(String[] args) { //crea un oggetto BankAccount uno= new BankAccount(600,"Fra"); System.out.println(uno.toString()); //prova di deposito uno.deposit(0,400); System.out.println(uno.getBalance()); //prova di prelievo uno.withdraw(0,500); System.out.println(uno.getBalance());

//prova di prelievo per un importo troppo grosso uno.withdraw(0,1000); System.out.println(uno.getBalance()); //creazione di un altro conto BankAccount due= new BankAccount(100,"Ale"); System.out.println(due.toString()); //prova di prelievo con un codice errato due.withdraw(0,100); System.out.println(due.getBalance()); //prova di prelievo con un codice giusto due.withdraw(1,100); System.out.println(due.getBalance()); //assegnamento tra oggetti-condivisione due=uno; due.withdraw(0,100); System.out.println(due.toString()); System.out.println(uno.toString());}}