Esercizi svolti con spiegazione di Ingegneria del software

MemorylessCalculatorDemo contenente il metodo main per eseguire i test.

Classe MemorylessCalculator:

public class MemorylessCalculator {

public static double add( double... values) {

if (values==null) {

throw new IllegalArgumentException("il valore non può essere nullo");

}

if (values.length<2) {

throw new IllegalArgumentException("sono necessari due o più numeri");

}

double risultato=0;

for (double value: values) {

risultato+=value;

}

return risultato;

}

}

La classe è progettata per non essere istanziata direttamente, dato che il metodo add è

statico. Quindi non è necessario creare un oggetto MemorylessCalculator per usare il metodo

add. Il metodo add utilizza i parametri (double… values) perciò può accettare un numero

arbitrario di argomenti, che siano numeri interi o reali. Prima di eseguire la somma il codice

verifica se il parametro values è null, se lo è viene lanciata un’eccezione

IllegalArgumentException con il messaggio “il valore non può essere nullo. Il codice controlla

anche che gli argomenti passati siano almeno due, se non lo sono, lancia un’altra eccezione

IllegalArgumentException. Se entrambi i controlli sono superati, il codice somma tutti i valori

passati come values e restituisce il risultato.

for (double value: values) è un ciclo che itera tutti gli elementi dell’array/collezione values,

→

double è il tipo di dati contenuto da values, e value è il valore di ogni singolo elemento in

values, a ogni ciclo assumerà il valore di un elemento di values, fino a iterarli tutti.

Classe MemorylessCalculatorDemo:

public class MemorylessCalculatorDemo {

public static void main(String[] args) {

Si utilizza la classe per testare il metodo add sella classe memorylesscalculator, all’interno

del metodo main.

try { add

MemorylessCalculator. (null);

}

catch(IllegalArgumentException e) {

out

System. .println("errore"+e);

si fa un primo test chiamando il metodo add con un valore null come argomento, viene

lanciata un’eccezione IllegalArgumentException, che viene catturata e gestita con il

messaggio stabilito.

try { add

MemorylessCalculator. ();

}

catch(IllegalArgumentException e) {

out

System. .println("errore"+e);

}

Si fa un secondo test chiamando il metodo add senza nessun argomento, poiché richiede

almeno due argomenti, viene lanciata un’altra eccezione, che viene catturata e gestita con il

messaggio.

try { add

MemorylessCalculator. (1);

}

catch(IllegalArgumentException e){

out

System. .println("errore"+e);

si fa un terzo test passando al metodo add un solo argomento, anche in questo caso viene

lanciata e gestita un’eccezione, poiché il metodo richiede almeno due argomenti.

out add

System. .println("risultato: "+ MemorylessCalculator. (1.2, 0.8));

out add

System. .println("risultato: "+ MemorylessCalculator. (1, 2, 3));

}

}

Si fa un ultimo test chiamando add con due, e poi tre, argomenti validi, il codice esegue la

somma e stampa il risultato come previsto.

Se proviamo a far stampare al codice la somma con un solo valore viene lanciata l’eccezione.

out add

System. .println("risultato: "+ MemorylessCalculator. (2));

catch(IllegalArgumentException e) {

illegalArgumentException è il tipo di eccezione che viene catturata, questo tipo di eccezione

viene lanciata quando si verifica un errore dovuto a un argomento non valido passato a un

metodo.

La variabile e è un identificatore che viene utilizzato per fare riferimento all’istanza

dell’eccezione che è stata lanciata. Questa variabile contiene tutte le informazioni relative

all’eccezione, come il messaggio di errore e la traccia dello stack, che descrive dove e perché

l’eccezione è stata lanciata. All’interno del blocco catch si può utilizzare e per accedere alle

informazioni sull’eccezione, ad esempio, usando e.getMessage(), si può ottenere il messaggio

di errore specifico. In questo caso e viene convertita automaticamente in una stringa e

stampata direttamente, il che include il tipo dell’eccezione e il suo messaggio di errore.

Crea una classe Account che rappresenta un conto bancario e che soddisfi i seguenti

requisiti (Fai attenzione all'accessibilità dei membri!):

• Ha un saldo

• Ha un numero di conto (supponiamo di tipo int)

• Account permette di depositare una somma

• Account permette di prelevare una somma

• Account permette di ottenere informazioni sul saldo attuale

• Account permette di ottenere informazioni sul numero di conto

• Account permette di stampare l'oggetto come Stringa

public class Account {

protected double saldo;

protected int numeroaccount;

si utilizza il modificatore di accesso protected per il saldo e il numero del conto, in modo che

possa essere accessibile solo dalla classe e dalle sue sottoclassi.

public Account(int a) {

saldo=0.0;

numeroaccount=a;

}

Si scrive un costruttore, un metodo che prende come parametro un intero a, numero del

conto. Quando viene creato un oggetto account il saldo viene inizializzato a zero e il numero

del conto viene impostato con il valore passato al costruttore.

public void deposita(double valoredadepositare) {

if (valoredadepositare>0) {

saldo+=valoredadepositare;

}

else { err

System. .println("non è possibile depositare una somma negativa");

}

Si definisce un metodo per depositare una somma di denaro sul conto, se la somma passata

al metodo è positiva viene aggiunta al saldo, se è negativa viene stampato un messaggio di

errore usando System.err.println, che segnala che non si può depositare una somma

negativa.

public void prelievo (double valoredaprelevare) {

if (saldo>valoredaprelevare) {

saldo-=valoredaprelevare;

}

else { err

System. .println("operazione non riuscita per mancanza di disponibilità");

}

}

Il metodo per prelevare funziona come il metodo per depositare.

public double informazionisaldo() {

return saldo;

}

public int informazioninumeroaccount() {

return numeroaccount;

}

Sono i metodi per avere informazioni per quanto riguarda il saldo disponibile e il numero

dell’account.

public String toString() {

return "numero dell'account: " + numeroaccount+ " saldo disponibile: " + saldo;

}

}

Metodo per avere le informazioni relative all’account direttamente come stringa.

• Utilizzando la classe Account come classe base, scrivi due classi derivate chiamate

SavingsAccount e CurrentAccount

• Un oggetto SavingsAccount, oltre agli attributi di un oggetto Account, dovrebbe avere

una variabile di interesse e un metodo che aggiunge l'interesse al conto

• Un oggetto CurrentAccount, oltre agli attributi di un oggetto Account, dovrebbe avere

una variabile di limite di scoperto. Assicurati di aver sovrascritto i metodi della classe

Account dove necessario in entrambe le classi derivate

• Ora crea una classe Bank, il cui oggetto contiene un array di oggetti Account. Gli

account nell'array potrebbero essere istanze della classe Account, della classe

SavingsAccount o della classe CurrentAccount. Crea alcuni account di prova (alcuni di

ciascun tipo).

Classe SavingsAccount:

public class SavingsAccount extends Account{

private double tassointeresse;

public SavingsAccount (int numeroaccount, double tassointeresse) {

super(numeroaccount);

this.tassointeresse=tassointeresse;

}

public void applicainteresse() {

double interesse= saldo*tassointeresse/100;

deposita(interesse);

}

@Override

public String toString() {

return "SavingsAccount [numero dell'account: " + numeroaccount + ", saldo disponibile: " +

saldo + ", tasso di interesse: " + tassointeresse + "%]";

}

}

Estende la classe account aggiungendo un tasso di interesse e un metodo per applicare

l’interesse al saldo. Si sovrascrive il metodo toString per ritornare anche le informazioni

relative al tasso di interesse.

Classe current account:

public class CurrentAccount extends Account {

private double limitescoperto;

public CurrentAccount(int numeroaccount, double limitescoperto) {

super(numeroaccount);

this.limitescoperto=limitescoperto;

}

@Override

public void prelievo(double valoredaprelevare) {

if (saldo+limitescoperto>valoredaprelevare) {

saldo-=valoredaprelevare;

}

else { err

System. .println("non è possibile prelevare per mancanza di disponibilità");

}

}

@Override

public String toString() {

return "numero account: " + numeroaccount+ " saldo: "+ saldo+ " limite di scoperto: "+

limitescoperto;

}

}

Questa classe estende la classe account. Si sovrascrive il metodo prelievo poiché oltre al

saldo effettivamente disponibile sul conto, si deve considerare anche lo scoperto, anche se il

saldo non è sufficiente, se non si supera il limite di scoperto si può prelevare. Si sovrascrive il

metodo toString per ritornare anche le informazioni relative al limite di scoperto.

entrambe le sottoclassi, quando si scrive il costruttore, si utilizza super per quanto

→per

riguarda numero account, perché si riferisce a un attributo che è della classe madre, cioè

della classe Account. Mentre per gli altri attributi, che non fanno parte della classe madre ma

solo delle classi figlie, non si usa super ma this nel costruttore.

Classe Bank:

public class Bank {

private Account[] accounts;

si dichiara un array chiamato accounts che conterrà oggetti di tipo account, è dichiarato

privato quindi sarà accessibile solo nella classe Bank.

private int accountcount;

è un contatore per tenere traccia del numero di account aggiunti all’array accounts.

public Bank(int size) {

accounts=new Account[size];

accountcount=0;

}

Si scrive il costruttore della classe Bank, che viene chiamato per costruire un nuovo oggetto di

tipo Bank, prende un parametro size che specifica la dimensione dell’array accounts. Crea un

array di oggetti di tipo Account con dimensione specificata pari a size. Il contatore viene

inizializzato a zero.

public void aggiungiAccount(Account account) {

if (accountcount<accounts.length) {

accounts[accountcount++]= account;

}

}

Permette di aggiungere un oggetto di tipo Account, chiamato account. Si controlla se

nell’array c’è spazio per inserire un nuovo oggetto. Se c’è spazio nell’array, l’account