Programmazione: classi e oggetti

Progettare la classe `ContoBancario`

Progettare e realizzare una classe che modella un conto bancario. Le funzioni che vogliamo considerare sono molto semplici:

depositare denaro;
prelevare denaro;
chiedere il saldo;

Ad esempio si vuole poter scrivere:

contoCarlo.deposita (300);
contoAndrea.preleva (50);
System.out.println (contoAndrea.saldo());

Questo implica che abbiamo individuato i metodi della nostra classe che ne regolano il comportamento:

deposita (double ammontare)
preleva (double ammontare)
saldo ()

Il modo di descrivere i metodi che abbiamo appena usato si chiama firma del metodo. La firma di un metodo specifica:

il numero e il tipo dei parametri che servono in input al metodo per poter computare correttamente;
il nome del parametro è l'identificatore del parametro formale, solo al momento della chiamata del metodo potremo sapere che valori effettivamente vengono assegnati al parametro.

È anche importante definire il tipo del valore che il metodo riporta all'ambiente che lo ha invocato. In questo caso oltre alla firma del metodo è necessario definirne il prototipo. Ad esempio per i metodi sopra definiti:

void deposita (double ammontare)
void preleva (double ammontare)
double saldo ()

I commenti secondo la sintassi richiesta dal programma d'utilità javadoc devono essere scritti in modo molto semplice e sintetico, come segue ad esempio:

/**
	Preleva denaro dal conto bancario.
	@param ammontare l'importo da prelevare
*/
public void preleva (double ammontare)
{
	// corpo del metodo in seguito
}

/**
	Chiede il saldo attuale del conto bancario.
	@return il saldo attuale
*/
public double saldo ()
{
	// corpo del metodo in seguito
}

Lo stato di ciascun conto bancario può essere descritto da una variabile d'istanza saldo che definiremo con accesso private in modo che solo i costruttori e i metodi della classe possano accedervi. Il costruttore di un oggetto della classe potrà inizializzare a 0 la variabile d'istanza saldo, come segue:

ContoBancario ()
{
	saldo = 0;
}

È anche ragionevole poter disporre di un costruttore con un parametro che indichi la cifra iniziale con cui inizializzare il saldo, e quindi possiamo anche definire un secondo costruttore:

ContoBancario (double saldoIniziale)
{
	saldo = saldoIniziale;
}

Il fatto che sia possibile chiamare i due costruttori con lo stesso identificatore si chiama overloading o sovraccaricamento. Il compilatore saprà scegliere il costruttore opportuno osservando i parametri passati al costruttore al momento della sua chiamata.

ContoBancario contoAndrea, contoCarlo;
contoAndrea = new ContoBancario ();
contoCarlo = new ContoBancario (500);

Ora occorre definire il corpo dei metodi di cui abbiamo identificato i prototipi. Innanzitutto in ogni nuova classe in generale definiremo:

public class NomeClasse
{
	campi
	costruttori
	metodi
}

e quindi la nostra classe ContoBancario sarà

public class ContoBancario
{
	private double saldo;

	public ContoBancario ()
	{
		saldo = 0;
	}

	public ContoBancario (double saldoIniziale)
	{
		saldo = saldoIniziale;
	}
	
	metodi
}

Definiamo ora i metodi deposita, preleva, saldo. Il campo saldo è stato dichiarato private e solo i metodi deposita e preleva potranno modificarne il valore, mentre il metodo saldo potrà leggerne il valore attuale.

/**
	Deposita denaro sul conto bancario
	@param ammontare l'importo da versare
*/
public void deposita (double ammontare)
{
	double nuovoSaldo = saldo + ammontare;
	saldo = nuovoSaldo;
}

/**
	Preleva denaro dal conto bancario
	@param ammontare l'importo da prelevare
*/
public void preleva (double ammontare)
{
	double nuovoSaldo = saldo - ammontare;
	saldo = nuovoSaldo;
}

/**
	Chiede il saldo attuale del conto bancario.
	@return il saldo attuale
*/
public double saldo ()
{
	return saldo;
}

La variabile nuovoSaldo è definita all'interno del corpo del metodo preleva, si dice allora che è una variabile locale. Le variabili locali si differenziano da quelle d'istanza per il ciclo di vita: infatti sono in vita solo durante l'esecuzione del metodo che le definisce. Anche il parametro di un metodo è una variabile che ha vita solo durante l'esecuzione del metodo. La differenza tra questi ultimi due tipi di variabili, variabili locali e parametri, sta nella diversa modalità d'inizializzazione. I parametri non vengono inizializzati esplicitamente perchè assumono il valore che viene loro passato all'atto della chiamata del metodo, le variabili locali devono invece essere inizializzate esplicitamente. La mancanza d'inizializzazione causa un errore.

Per effettuare una prova della classe ContoBancario occorre definire una classe TestContoBancario.

Progettare la classe ContoBancario

Progettare la classe `ContoBancario`