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. Ci basta quindi una sola variabile di istanza:

                             
   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?
Come una qualunque variabile, specificandone anche la visibilità.
 
 
Sintassi:

<SpecAccesso> <Tipo> <Nome>;
<SpecAccesso> <Tipo> <Nome> = <espressione>; // inizializzazione
Esempi: 
    private double balance;
    private double balance = 0;

Effetto: Ogni oggetto della classe BankAccount ha una propria variabile balance.

  • <SpecAccesso>  determina la visibilità della variabile. 

    • private: la variabile è visibile solo all'interno della classe. 

    • public: è visibile ovunque. 

    • Se <SpecAccesso>  manca, la variabile  è visibile in tutte le classi del package.
        
  • <Tipo> è il tipo della variabile.

    •  
  • <Nome>  è il nome della variabile.

    •  
  • <espressione>: se presente, la variabile viene inizializzata con il suo valore.

Operazioni...
Decidiamo di considerare solo le seguenti operazioni su di un conto bancario:
  • depositare denaro

    •  
  • prelevare denaro

    •  
  • chiedere il saldo corrente

... e metodi corrispondenti

I metodi corrispondenti saranno (in inglese...)
  • 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)

    public void withdraw(double amount)

    public double getBalance()

Attenzione: si tratta di metodi d'istanza, non statici, come si vede dall'assenza della keyword static.


Come si dichiara un metodo?
Esattamente come visto per i metodi statici, omettendo la parola chiave static. Rivediamo la sintassi:

Sintassi:

<SpecAccesso> <Tipo> <Nome>(<Parametri>) { 
    <Comandi>
}
Esempio: 
    public void deposit(double amount) { 
        balance = balance + amount;
    }

  • <SpecAccesso>  determina la visibilità del metodo (ad es. public, private)

    •  
  • <Tipo> è il tipo del risultato del metodo (void se il metodo non restituisce niente [procedura], oppure double, int, String, int [], ... [funzione])

    •  
  • <Nome>  è il nome del metodo (un identificatore)

    •  
  • <Parametri> è una sequenza di coppie  <Tipo> <Nome>  separate da virgola.
 
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.

Ad esempio, vogliamo poter scrivere:
  
    BankAccount c1 = new BankAccount(); 
        //nuovo conto con saldo 0
  
    BankAccount c2 = new BankAccount(1000); 
        // conto con saldo 1000

Questo si ottiene introducendo i seguenti costruttori:
  
public class BankAccount{ 

   private double balance; 

   public BankAccount(){ 
      ...
   }

   public BankAccount(double initialBalance){ 
      ...
   }

  .... 
}

 
Come si dichiara un costruttore?
Come un metodo, ma:
  • il nome deve essere lo stesso della classe

    •  
  • non si specifica un tipo
 
Sintassi:

<SpecAccesso> <NomeClasse>(<Parametri>) { 
    <Comandi>
}
Esempio: 
public BankAccount(double initialBalance) {
   balance = initialBalance; 
}

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.

 


Interfaccia pubblica di una classe
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.

L'interfaccia pubblica di tutte le classi della distribuzione standard di Java è documentata nella Java API (Application Programming Interface) [Medialab, Sun].

L'interfaccia pubblica della classe BankAccount è la seguente:

    public BankAccount()

    public BankAccount(double initialBalance)

    public void deposit(double amount)

    public void withdraw(double amount)

    public double getBalance()

Conoscendo l'interfaccia possiamo usare gli oggetti della classe, anche senza sapere come siano realizzati.

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);