Implementare e testare una classe Bank che contenga un ArrayList di oggetti di tipo BankAccount e abbia i seguenti metodi:

• addAccount(initialBalance, customerName)
• deposit(accountNumber, amount)
• withdraw(accountNumber, amount)
• getBalance(accountNumber)
• transfer(fromAccNumber, toAccNumber, amount)

La classe BankAccount fornirà i classici metodi per il deposito e il prelievo nonchè i metodi per la restituzione delle informazioni in esso contenute.
Realizzare inoltre una classe di test.

La classe BankAccount.java:

public class BankAccount
{

  // Metodo Costruttore inizializzato con nome proprietario, saldo e numeroAcc
  public BankAccount(double a, String n, int num)
  {
      acconto = a;
      nome = n;
      numAcc = num;
  }

  // Metodo per il deposito di denaro nel conto
  public void deposit(double s)
  {
      double temp = acconto;
      acconto = temp + s;
  }

  // Metodo per il prelievo di denaro dal conto
  public void withdraw(double s)
  {
      double temp = acconto;
      acconto = temp - s;
  }

  // Metodo che restituisce il valore del conto
  public double getBalance()
  {
      return acconto;
  }

  // Metodo che restituisce il numero di conto
  public int getNumber()
  {
      return numAcc;
  }

  // Metodo che restituisce il numero di conto
  public int getName()
  {
      return nome;
  }

  private int numAcc;
  private double acconto;
  private String nome;
}

La classe Bank che gestisce la collezione di BankAccount:

import java.util.ArrayList;
public class Bank
{
ArrayList<BankAccount> banca;

  // Metodo Costruttore
  public Bank()
  {
      this.banca = new ArrayList<BankAccount>();
  }

  // Metodo che aggiunge un nuovo conto nella banca
  public void addAccount(double b, String nome)
  {
      int i = banca.size() + 1;
      BankAccount  bk = new BankAccount(b,nome,i);
      banca.add(bk);
  }

  // Metodo che permette di depositare denaro in un conto daro il numeroConto
  public void deposit(int n , double s)
  {
      for(int j=0; j<banca.size(); j++)
      {
          BankAccount temp = (BankAccount) banca.get(j);
          int number = temp.getNumber();
          if(number == n)
          {
              temp.deposit(s);
          }
      }
  }

  // Metodo che permette di sottrarre una somma a un conto dato un numeroConto
  public void withdraw(int n,double s)
  {
       for(int j=0; j<banca.size(); j++)
       {
          BankAccount temp = (BankAccount) banca.get(j);
          int number = temp.getNumber();
          if(number == n)
          {
              temp.withdraw(s);
          }
       }
  }

  //Metodo che restituisce il valore del conto dato un numeroConto
  public String getBalance(int n)
  {
      for(int j=0; j<banca.size(); j++)
      {
           BankAccount temp = (BankAccount) banca.get(j);
           if(temp.getNumber()==n){
                return "Conto codice "+temp.getNumber()+" con importo "+temp.getBalance();
           }
      }
      return "Conto non trovato!";
  }

  // Metodo che trasferisce una somma di denaro da un conto ad un altro
  public boolean transfer(int n1, int n2, double d)
  {
	  BankAccount uscita = null;
	  BankAccount entrata = null;
	  for(int j=0; j<banca.size(); j++)
	  {
		  BankAccount temp = (BankAccount) banca.get(j);
		  if(temp.getNumber()==n1){
			  uscita = temp;
		  }
		  if(temp.getNumber()==n2){
			  entrata = temp;
		  }
	  }
	  if(uscita!=null && entrata!=null){
		  uscita.withdraw(d);
		  entrata.deposit(d);
		  return true;
	  }
	  return false;
  }
}

La classe di test:

public class TestaBanca
{
  public static void main(String[] args)
  {
    // Creo un nuovo oggetto Bank
    Bank prova = new Bank();

    // Aggiungo 4 nuovi conti
    prova.addAccount(2000,"Marco Rossi");
    prova.addAccount(1000,"Enzo Bianchi");
    prova.addAccount(500,"Lucia Neri");
    prova.addAccount(700,"Silvia Rossini");

    // Effettuo alcune operazioni sui conti
    prova.deposit(1,200);
    prova.withdraw(2,1000);

    // Visualizzo a video lo stato dei conti presenti nella banca
    System.out.println(prova.getBalance(1));
    System.out.println(prova.getBalance(2));
    System.out.println(prova.getBalance(3));
    System.out.println(prova.getBalance(4));

    // Trasferisco una somma di denaro da un conto all'altro
    double somma = 100;
    if(prova.transfer(1, 2, somma)==true){
    	System.out.println("Trasferimento denaro avvenuto correttamente!");
    }else{
    	System.out.println("Errore nel trasferimento di denaro!");
    }

    // Ristampo lo stato dei due conti soggetti a trasferimento denaro
    System.out.println(prova.getBalance(1));
    System.out.println(prova.getBalance(2));
  }
}

Implementare e testare una classe Purse come collezione di monete.
Una moneta è un’istanza di una classe Coin:
gli oggetti di Coin sono immutabili e hanno un nome (nome della moneta) e un valore (valore della moneta).

Deve essere possibile recuperare l’informazione contenuta in ogni oggetto Coin oltre che implementare i seguenti metodi:

• addCoin(Coin aCoin): aggiungere una moneta al portafoglio
• conteggio(String nomeCoin): conta il numero di monete dato un nome moneta
• getTotal(): restituisce il totale monete presenti nel portafoglio
• remove(Coin aCoin): rimuove una moneta di valore pari a a Coin se presente nella borsa
• find(Coin aCoin): restituisce l’indice di una moneta di valore pari a Coin (private)

Vediamo innanzitutto la semplice classe Coin.java:

public class Coin
{
	double valore;
	String nome;

	// Metodo Costruttore Coin inizializzato con nome moneta e relativo valore
	public Coin(double v, String n){
		valore = v;
		nome = n;
	}

	// Metodo che restituisce il valore della moneta
	public double getValue(){
		return valore;
	}

	// Metodo che restituisce il nome della moneta
	public String getNome(){
		return nome;
	}
}

Quindi la classe che gestisce la collezzione di monete Purse.java:

import java.util.ArrayList;
public class Purse
{
private ArrayList<Coin> lista;

  	// Metodo Costruttore vuoto
  	public Purse(){
  		this.lista = new ArrayList<Coin>();
  	}

  	public void addCoin(Coin c){
  		lista.add(c);
  	}

  	// Metodo che restituisce il totale di monete presenti nel portafoglio
  	public void getTotal()
  	{
  		double totale = 0;
  		for(int i=0 ; i<lista.size(); i++)
  		{
  			Coin a = (Coin) lista.get(i);
  			double t = a.getValue();
  			totale = totale + t;
  		}
  		System.out.println(totale);
  	}

  	/* Metodo che conta il numero di monete presenti nel portafoglio
       data una moneta
  	 **/
  	public int conteggio(String nome)
  	{
  		int c = 0;
  		for(int i=0 ; i<lista.size(); i++)
  		{
  			Coin a = (Coin) lista.get(i);
  			String m = a.getNome();
  			if(m.equalsIgnoreCase(nome))
  			{
  				c++;
  			}
  		}
  		return c;
  	}

  	// Metodo che elimina una moneta dal portafolio
  	public String remove(Coin a)
  	{
  		String nome = a.getNome();
  		int i =0;
  		while (i < lista.size())
  		{
  			Coin b = (Coin) lista.get(i);
  			String v = b.getNome();
  			if(v.equalsIgnoreCase(nome))
  			{
  				lista.remove(i);
  				return "Moneta eliminata";
  			}
  			i++;
  		}
  		return "Moneta non presente";
  	}

  	// Metodo che verifica l'uguaglianza tra due monete
  	public boolean find(Coin a)
  	{
  		String nome = a.getNome();
  		int i =0;
  		while (i < lista.size())
  		{
  			Coin b = (Coin) lista.get(i);
  			String v = b.getNome();
  			if(v.equalsIgnoreCase(nome))
  			{
  				return true;
  			}
  			i++;
  		}
  		return false;
  	}
}

Infine una classe di test che permette all’utente di accedere, tramite un menu, alle funzioni di aggiunta moneta, rimozione moneta, stampa del saldo, conteggio e ricerca di monete.
La classe TestPurse.java:

import java.util.Scanner;
public class TestPurse {

	public static void main(String[] args)
	{
		// Costruisco un oggetto Purse
		Purse fabio = new Purse();
		Scanner in = new Scanner(System.in);

		String exit = "no";

	    // Visualizzo le varie procedure possibili
	    while (exit.equalsIgnoreCase("no"))
	    {
		    System.out.println("  *** MENU *** ");
		    System.out.println("1 - Aggiungere monete");
		    System.out.println("2 - Sottrarre monete");
		    System.out.println("3 - Cercare una moneta");
		    System.out.println("4 - Stampare il totale borsa");
		    System.out.println("5 - Esci");

		    int menu= in.nextInt();
		    String continua = "si";
		    String continua2 = "si";
		    // Aggiungo monete al portafoglio
		    if(menu == 1){
		    	while (continua.equalsIgnoreCase("si")){
			        System.out.println("Quale moneta vuoi aggiungere alla borsa?");
			        System.out.println("1 - 1 Euro");
			        System.out.println("2 - 2 Euro");
			        System.out.println("3 - 50 Centesimi di Euro");
			        System.out.println("4 - 20 Centesimi di Euro");

			        int scelta = in.nextInt();

			        if(scelta == 1){
			        	Coin moneta = new Coin(1,"Un Euro");
			        	fabio.addCoin(moneta);
			        }
			        if(scelta == 2){
			        	Coin moneta = new Coin(2,"Due Euro");
			        	fabio.addCoin(moneta);
			        }
			        if(scelta == 3){
			        	Coin moneta = new Coin(0.50,"50 Centesimi");
			        	fabio.addCoin(moneta);
			        }
			        if(scelta == 4){
			        	Coin moneta = new Coin(0.20,"20 Centesimi");
			        	fabio.addCoin(moneta);
			        }
			        // Stampo a video il contenuto del portafoglio
			        System.out.print("Nella tuo portafoglio è presente questa somma: ");
			        fabio.getTotal();
			        System.out.print("Vuoi continuare a inserire monete?");
			        continua = in.next();
		    	}
		    }
		    // Elimino monete dal portafoglio
		    if(menu == 2){
		    	while ( continua2.equalsIgnoreCase("si")){
		            System.out.println("Quale moneta vuoi eliminare dalla borsa?");
		            System.out.println("1 - 1 Euro");
		            System.out.println("2 - 2 Euro");
		            System.out.println("3 - 50 Centesimi di Euro");
		            System.out.println("4 - 20 Centesimi di Euro");

		            int scelta = in.nextInt();

		            if(scelta == 1){
		               Coin daEliminare = new Coin(1,"Un Euro");
		               System.out.println(fabio.remove(daEliminare));
		            }
		            if(scelta == 2){
		                Coin daEliminare = new Coin(2,"Due Euro");
		                System.out.println(fabio.remove(daEliminare));
		            }
		            if(scelta == 3){
		                Coin daEliminare = new Coin(0.50,"50 centesimi");
		                System.out.println(fabio.remove(daEliminare));
		            }
		            if(scelta == 4){
		                Coin daEliminare = new Coin(0.20,"20 centesimi");
		                System.out.println(fabio.remove(daEliminare));
		            }
		            // Stampo a video il contenuto del portafoglio
		            System.out.print("Nella tua borsa è presente questa somma: ");
		            fabio.getTotal();
		            System.out.print("Vuoi continuare a eliminare monete?");
		            continua2 = in.next();
		    	}
		    }

		    // Cerco una moneta nel portafoglio
		    if (menu == 3){
		        System.out.println("Quale moneta vuoi cercare nella borsa?");
		        System.out.println("1 - Un Euro");
		        System.out.println("2 - Due Euro");
		        System.out.println("3 - 50 Centesimi");
		        System.out.println("4 - 20 Centesimi");

		        int scelta = in.nextInt();

		        if(scelta == 1){
		               Coin daCercare = new Coin(1,"Un Euro");
		               System.out.println(fabio.find(daCercare));
		        }
		        if(scelta == 2){
		                Coin daCercare = new Coin(2,"Due Euro");
		                System.out.println(fabio.find(daCercare));
		        }
		        if(scelta == 3){
		                Coin daCercare = new Coin(0.50,"50 centesimi");
		                System.out.println(fabio.find(daCercare));
		        }
		        if(scelta == 4){
		                Coin daCercare = new Coin(0.20,"20 centesimi");
		                System.out.println(fabio.find(daCercare));
		        }
		    }

		    // Stampo a video il contenuto del portafoglio
		    if(menu == 4){
		    	System.out.print("Il totale della borsa è : ");
		    	fabio.getTotal();
		    }

		    // Termino esecuzione
		    if (menu == 5){
		    	exit = "si";
		    }
	    }
        }
}

Cliccando qui è possibile scaricare l’eseguibile.

Scrivere un programma che si comporta come segue:

• Crea due conti correnti uno (conto giocatore) con importo iniziale pari a 1000 euro ed uno (conto casinò) con importo iniziale pari a 100000 euro.
• Prende in input da tastiera un intero n e un double somma e simula il lancio di un dado (con 6 facce). Se il risultato del lancio è n allora il programma trasferisce un importo pari a 5 volte il valore di somma dal conto del casinò al conto del giocatore; se il risultato è diverso da n il programma trasferisce un importo pari a somma dal conto del giocatore a quello del casinò. Il valore di somma deve essere inferiore al saldo del vostro conto e 5 volte più piccolo di quello del conto del casinò.
• Se dopo la scommessa il giocatore dispone ancora di soldi sul conto, il programma chiede se volete continuare a scommettere. Se digitate “si” il programma continua dal punto 2. Se digitate qualcosa di diverso da “si” oppure il saldo è zero il programma si interrompe stampando il saldo del vostro conto.

Infondo all’esercizio è possibile lanciare e scaricare l’eseguibile.

Innanzitutto il codice della classe Dado.java:

import java.util.Random;
public class Dado {
	// Metodo Costruttore. Numero di facce impostato a 6.
	public Dado()
	{
		facce = 6;
		generatore = new Random();
	}

	// Metodo che simula il lancio del dado
	public int lancia()
	{
		return 1 + generatore.nextInt(facce);
	}

	private Random generatore;
	private int facce;
}

Quindi le classi per gestire i due conti.
ContoGiocatore.java:

public class ContoGiocatore
{
	double contoGio;

	// Metodo Costruttore inizializzato con un valore double
	public ContoGiocatore(double c)
	{
		contoGio = c;
	}

	// Metodo che restituisce l'importo del conto giocatore
	public double getContoGiocatore()
	{
		return contoGio;
	}

	// Metodo che permette di sottrarre la somma persa dal giocatore
	public void sottraiContoGiocatore(double s)
	{
		double temp = contoGio;
		temp = temp - s;
		contoGio = temp;
	}

	/** Metodo che permette di aggiungere la somma vinta dal giocatore.
      Somma vinta = somma giocata * 5.
	 */
	public void aumentaContoGiocatore(double s)
	{
		double temp = 5*s;
		contoGio = contoGio + temp;
	}
}

ContoCasino.java:

public class ContoCasino
{
	double contoCas;

	// Metodo Costruttore ContoCasinò inizializzato con un valore double
	public ContoCasino(double c)
	{
		contoCas = c;
	}

	// Metodo che restituisce l'importo del conto casinò
	public double getContoCasino()
	{
		return contoCas;
	}

	/** Metodo che permette di sottrarre una somma vinta da un giocatore
        al conto del casinò.
        La somma sottratta è pari alla somma giocata dal giocatore moltiplicata
        per cinque.
	 */
	public void sottraiContoCasino(double s)
	{
		double temp = contoCas;
		double temp1 = s*5;
		temp = temp - temp1;
		contoCas = temp;
	}

	/** Metodo che permette di aggiungere una somma persa da un giocatore
        al conto del casino
	 */
	public void sommaContoCasino(double s)
	{
		double temp = contoCas;
		temp = temp + s;
		contoCas = temp;
	}
}

Quindi infine la classe di test che si chiamerà VaiAlCasino.java:

import java.util.Scanner;
public class VaiAlCasino
{

	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);

		// Costruisco un oggetto dado
		Dado d = new Dado();

		// Costruisco un nuovo oggetto giocatore e uno casinò
		ContoGiocatore fabio = new ContoGiocatore(1000);
		ContoCasino casino = new ContoCasino(100000);

		String verifica = "si";
		System.out.println("*** BENVENUTI AL CASINò ***");

		// Simulo la giocata
		while ( verifica.equalsIgnoreCase("si"))
		{
			// Scelgo un numero del dado
			System.out.println("Scegli un numero:");
			int num = in.nextInt();
			if(num>0 && num<7)
			{
				// Punto una somma di denaro
				System.out.println("Punta una somma di denaro: ");
				System.out.print("(ricorda che il tuo credito è pari a " + fabio.getContoGiocatore());
				System.out.println(" )");
				double somma = in.nextDouble();

				double contoG = fabio.getContoGiocatore();
				double contoC = casino.getContoCasino();
				double contoCc = contoC/5;

				// Verifico la puntata e il budget del casinò
				if ( somma <= contoG && somma <= contoCc)
				{
					// Simulo il lancio del dado
					System.out.println("Lancio il dado...");
					int lancio = d.lancia();
					System.out.print("Il risulatato del dado è :  ");
					System.out.println(lancio);

					// Verifico se il giocatore vince o perde
					if ( lancio == num)
					{
						System.out.println("Complimenti hai vinto");
						fabio.aumentaContoGiocatore(somma);
						casino.sottraiContoCasino(somma);
					}else{
						System.out.println("Peccato, hai perso");
						casino.sommaContoCasino(somma);
						fabio.sottraiContoGiocatore(somma);
					}

				}else{
					System.out.println("Non puoi puntare quella somma");
				}

				double newSomma = fabio.getContoGiocatore();

				// Verifico se il giocatore può continuare a giocare
				if ( newSomma > 0)
				{
					// Il giocatore sceglie se continuare a giocare
					System.out.println("Vuoi continuare a scommettere?");
					verifica = in.next();
					System.out.print("Il tuo conto è pari a :  ");
					System.out.println(fabio.getContoGiocatore());
				}else{
					System.out.println("CONTO ESAURITO");
					System.out.println(fabio.getContoGiocatore());
					verifica = "no";
				}
			}
		}
	}
}

Cliccando qui è possibile scaricare l’eseguibile.

Scrivere e testare un programma che data una parola w ed un testo t conta il numero di occorrenze di w in t.

La classe ContaOccorrenze.java:

public class ContaOccorrenze {
	String testo;

	// Il costruttore inizializza il testo sul quale effettuare la ricerca
	public ContaOccorrenze(String txt){
		this.testo = txt;
	}

	// Il metodo conta acquisisce in input la parola da cercare
	public int conta(String parola){
		// Calcolo la lunghezza del testo e della parola
	    int lunghezza_parola = parola.length();
	    int lunghezza_testo = testo.length();

	    // Definisco due variabili: un indice per il testo e un contatore
	    int indice = 0;
	    int numeroParole = 0;

	    // Fin quando l'indice del testo è valido
	    while (indice <= lunghezza_testo-lunghezza_parola){
	    	// Controllo se la substring del testo è uguale alla parola
	    	if(testo.subSequence(indice, indice+lunghezza_parola).equals(parola)){
	    		numeroParole++;
	    	}
	    	// L'indice aumenta ad ogni iterazione
	    	indice++;
	    }
	    return numeroParole;
	}
}

La classe di test ContaParola.java:

import java.util.Scanner;
public class ContaParola
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);

	    // Prendo in input un testo
	    System.out.println("Scrivi un testo: ");
	    String testo = in.nextLine();

	    // Prendo in input una lettera da cercare nel testo
	    System.out.println("Dammi una parola da ricercare e conteggiare: ");
	    String parola = in.nextLine();

               // Istanzio l'oggetto ContaOccorrenze
	    ContaOccorrenze contatore = new ContaOccorrenze(testo);
               // Invovo il metodo che restituisce il numero di occorrenze di parola in testo
	    int occorrenze = contatore.conta(parola);

	    System.out.println("La parola è presente : ");
	    System.out.println(occorrenze + " volte");
	}
}

Realizzare una classe PrimeGenerator con metodo nextPrime() che genera il prossimo numero primo.
Scrivere e testare un programma che chiede all’utente un intero n e stampa tutti i numeri primi compresi tra 2 ed n.
Ad esempio se l’input è 20, il programma stampa:
2
3
5
7
11
13
17
19

La classe PrimeGenerator.java:

public class PrimeGenerator
{
	int numero;

  	// Metodo Costruttore vuoto
	public PrimeGenerator(int n){
		this.numero = n;
		nextPrime(2);
	}

	// Metodo che calcola i numeri primi compresi tra 1 e n
	public void nextPrime(int n)
	{
	    int posMax = (int)Math.sqrt(n + 1);

	    for(int divisore = 2; divisore <= posMax; divisore++){
	    	if (n % divisore == 0 && n!=2){
	    		if(n<=numero){
	    			nextPrime(n+1);
	    		}
	    		return;
	    	}
	    }
	    System.out.println(n);
	    if(n<=numero){
	    	nextPrime(n+1);
	    }
	}
}

La classe di test:

import java.util.Scanner;
public class TestPrime
{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);

		// Prendo in input un numero
		System.out.println("Dammi un numero: ");
		int num = in.nextInt();

		PrimeGenerator NumeriPrimi = new PrimeGenerator(num);

	}
}

Realizzare una classe FibGen con metodo nextNumber() che genera il prossimo numero di Fibonacci.
Si ricorda che f0 = 1, f1 = 1 e fn = fn-1 + fn-2
Scrivere e testare un programma che dato in input un intero n stampa l’ennesimo numero di Fibonacci.

La classe FibGen.java:

public class FibGen
{

  // Metodo Costruttore vuoto
  public FibGen()
  {
  }

  // Metodo ricorsivo per il calcolo del relativo numero di Fibonacci
  public int nextNumber(int numero)
  {
    if(numero==0 || numero==1)
    {
        return 1;
    }
    else
    {
        // Chiamata ricorsiva
        return this.nextNumber(numero-1)+this.nextNumber(numero-2);
    }
  }
}

La classe di test TestFibonacci.java:

import java.util.Scanner;
public class TestFibonacci
{

  public static void main(String[] args)
  {
    // Creo un nuovo oggetto FibGen
    FibGen f = new FibGen();
    Scanner in = new Scanner(System.in);

    // Prendo in input un numero intero
    System.out.println("Dammi un numero intero di cui vuoi conoscere il numero di Fibonacci : ");
    int n = in.nextInt();

    // Calcolo il numero di Fibonacci relativo all'input
    System.out.println(f.nextNumber(n));
  }
}

Scrivere un programma che legge in input un intero n e stampa un triangolo isoscele con n righe formate da ‘*’.
Esempio: se l’input è 4 stampa:

La classe StampaTriangolo.java:

public class StampaTriangolo
{
int righe;

  // Metodo Costruttore inizializzato con un intero n
  public StampaTriangolo(int n)
  {
    righe = n;
  }

  // Metodo che stampa a video il triangolo
  public void eseguiTriangolo()
  {
    int i = righe;
    int iu = i;
    int k = 0;
    for(int j=1 ; j<i+1 ; j++)
    {
        int s = j + k;
        for(int z=iu ; z>0 ; z--)
        {
          System.out.print("   ");
        }

        for(int t=0 ; t< s ; t++)
        {
            System.out.print(" * ");
        }
        System.out.println("");
        k++;
        iu = iu -1 ;
    }
  }
}

La classe che contiene il main TestStampa.java:

import java.util.Scanner;
public class TestStampa {
  public static void main(String[] args)
  {
    Scanner in = new Scanner(System.in);

    // Prendo in input un intero, numero di righe nel triangolo
    System.out.println("Dammi il valore n del triangolo: (max 18) ");
    int num = in.nextInt();

    // Creo un nuovo oggetto StampaTriangolo
    StampaTriangolo tri = new StampaTriangolo(num);

    // Chiamo il metodo per stampare il triangolo
    tri.eseguiTriangolo();
  }
}

Scrivere un programma che chieda all’utente di inserire il tasso di cambio fra dollari ed euro. Il programma legge alcuni valori in dollari e li converte in euro fino a che l’utente non digita lo zero (0).

La classe Cambio.java:

public class Cambio
{
private double tasso;

  // Metodo Costruttore inizializzato con il tasso di cambio
  public Cambio(double t)
  {
    tasso = t;
  }

  // Metodo che permette di convertire una somma di denaro
  public double conversione(double v)
  {
    double temp = v * tasso;
    return temp;
  }

  // Metodo che restituisce il valore del tasso di cambio
  public double daiTassoCambio()
  {
    return tasso;
  }
}

La classe di test:

import java.util.Scanner;
public class TestCambio
{
  public static void main(String[] args)
  {
      Scanner in = new Scanner (System.in);

      // Prendo in input il tasso di cambio
      System.out.println("Dammi il tasso di cambio");
      double tax = in.nextDouble();

      // Creo un nuovo oggetto Cambio
      Cambio m = new Cambio(tax);

      double o = 1;

      // Effettuo il cambio tra monete
      while(o!=0)
      {
	System.out.println("Inserisci valore da convertire: (0 per uscire)");
	o = in.nextDouble();

	if(o!=0){
	    System.out.println("Col cambio : " + m.conversione(o));
	}else{
	    System.out.println("Programma concluso!");
	}
      }
  }
}

Realizzare una classe per rappresentare una serratura con combinazione di 3 lettere maiuscole.
I metodi sono

• void setPosition(String) // inserisce una lettera del codice
• void reset() // azzera la combinazione inserita
• void unlock() //apre la serratura se il codice passato è quello della serratura
• boolean isOpen() // verifica se la serratura è aperta
• void lock() // chiude la serratura
• void newComb(String) // assegna la nuova combinazione se la serratura è aperta

Ecco la classe Serratura.java:

public class Serratura
{
  String codice;
  String codInserito = null;
  String verifica = null;

  // Metodo Costruttore inizializzato con codice di tre lettere
  public Serratura(String c)
  {
    int lung = c.length();
    if(lung==3 && c.equals(c.toUpperCase()))
    {
        codice = c;
    }
    else
    {
        // Lancia eccezione se il codice non è di 3 lettere
        throw new IllegalArgumentException("Codice non valido.");
    }
  }

  // Metodo che permette di inserire il codice, un carattere per volta
  public void setPosition(String uno ,String due, String tre)
  {
    String temp = uno+due;
    String temp1 = temp+tre;
    codInserito = temp1;
  }

  // Metodo che permette di aprire la serratura se il codice è esatto
  public void unlock()
  {
      if ( codInserito.equals(codice))
      {
          verifica = "APERTA";
          System.out.println("Serratura Aperta");
      }
      else
      {
          verifica = "CHIUSA";
          System.out.println("Serratura chiusa");
      }
  }

  // Metodo che verifica lo stato della serratura
  public String isOpen()
  {
    String isOp = null;
    if(verifica.equals("APERTA"))
    {
      isOp = "Serratura aperta";
    }
    else
    {
      isOp = "Serratura chiusa";
    }
    return isOp;
  }

  // Metodo che permette di chiudere la serratura
  public void lock()
  {
    verifica = "CHIUSA";
    codInserito = null;
  }

  // Metodo che permette di settare un nuovo codice di serratura
  public void newComb(String nc)
  {
    if(verifica.equals("APERTA"))
    {
      codice = nc;
      verifica = "CHIUSA";
    }
    else
    {
      System.out.println("Serratura chiusa. ACCESSO NEGATO.");
    }
  }
}

La classe di test:

import java.util.Scanner;
public class TestSerratura {

  public static void main(String[] args)
  {
    Scanner in = new Scanner (System.in);

    // Creo una nuova serratura
    Serratura s = new Serratura("TRE");

    // Prendo in input le 3 lettere del codice
    System.out.println("Inserisci prima lettera codice : ");
    String c = in.nextLine();
    System.out.println("inserisci seconda lettera codice : ");
    String c1 = in.nextLine();
    System.out.println("Inserisci terza lettare codice : ");
    String c2 = in.nextLine();
    s.setPosition(c,c1,c2);

    // Verifico se il codice apre la serratura
    s.unlock();

    // Verifico lo stato della serratura
    System.out.println("Lo stato della serratura è : " +s.isOpen());

    // Setto una nuova combinazione se la serratura è aperta
    s.newComb("REE");

    // Verifico il nuovo stato della serratura
    System.out.println(s.isOpen());
  }
}

Per ulteriori prove modificare il codice della serratura, modificando il valore in input al costruttore. Da notare anche il primo uso delle eccezioni.

Realizzare una classe Year con metodo predicativo isLeapYear() e metodo getYear().
Classe Month con metodi getDays() che restituisce il numero di giorni del mese e getMonth() che restituisce il nome del mese.
Scrivere un programma che dato il numero di un mese e un anno restituisce il nome del mese, l’anno, se l’anno è bisestile e infine stampi l’elenco dei giorni.

La classe Year.java

public class Year
{
int anno;

  // Metodo Costruttore inizializzato con anno
  public Year(int a)
  {
    if(a>=1980 && a<=2100)
    {
        anno = a;
    }
    else
    {
        // Lancia un'eccezione se l'anno non è compreso tra 1980 e 2100
        throw new IllegalArgumentException("Formato anno non valido");
    }
  }

  // Metodo che restituisce l'anno
  public int getYear()
  {
    return anno;
  }

  // Metodo che verifica se l'anno è bisestile
  public String isLeapYear()
  {
    String verifica = "NO";

    int annoCorrente = this.getYear();
    if(annoCorrente % 4 == 0){
    	System.out.println("Anno bisestile");
        verifica = "bisestile";
    }
    return verifica;
  }
}

La classe Month.java

public class Month
{
int mese;
int anno;
Year ann;

  // Metodo Costruttore inizializzato con il numero del mese e un oggetto Year
  public Month(Year a,int m)
  {
    mese = m;
    ann = a;
    anno = a.getYear();
  }

  // Metodo che restituisce il nome del mese
  public void getMonth()
  {
    if (mese >=1 && mese < 13)
    {
      if (mese==1){  System.out.print("GENNAIO  ");}
      if (mese==2){  System.out.print("FEBBRAIO ");}
      if (mese==3){  System.out.print("MARZO  ");}
      if (mese==4){  System.out.print("APRILE ");}
      if (mese==5){  System.out.print("MAGGIO ");}
      if (mese==6){  System.out.print("GIUGNO ");}
      if (mese==7){  System.out.print("LUGLIO ");}
      if (mese==8){  System.out.print("AGOSTO ");}
      if (mese==9){  System.out.print("SETTEMBRE  ");}
      if (mese==10){  System.out.print("OTTOBRE ");}
      if (mese==11){  System.out.print("NOVEMBRE  ");}
      if (mese==12){  System.out.print("DICEMBRE  ");}
    }
    else
    {
      System.out.println("Formato mese non valido");
    }
  }

  // Metodo che restituisce il numero di giorni corrispondente al mese
  public void getDays()
  {
    String v = ann.isLeapYear();
    if(mese == 2)
    {
      // Se il mese è Febbraio verifica l'anno se bisestile
      if(v.equalsIgnoreCase("bisestile"))
      {
        System.out.println("  1   2   3   4   5   6   7 ");
        System.out.println("  8   9   10  11  12  13  14");
        System.out.println("  15  16  17  18  19  20  21");
        System.out.println("  22  23  24  25  26  27  28");
        System.out.println("  29    ");
      }
      else
      {
        System.out.println("  1   2   3   4   5   6   7 ");
        System.out.println("  8   9   10  11  12  13  14");
        System.out.println("  15  16  17  18  19  20  21");
        System.out.println("  22  23  24  25  26  27  28");
      }
    }
    if(mese==1 || mese==3 || mese==5 || mese==7 || mese==8 || mese==10 || mese==12)
    {
      System.out.println("  1   2   3   4   5   6   7 ");
      System.out.println("  8   9   10  11  12  13  14");
      System.out.println("  15  16  17  18  19  20  21");
      System.out.println("  22  23  24  25  26  27  28");
      System.out.println("  29  30  31  ");
    }
    if(mese==4 || mese==6 || mese==9 || mese ==11)
    {
      System.out.println("  1   2   3   4   5   6   7 ");
      System.out.println("  8   9   10  11  12  13  14");
      System.out.println("  15  16  17  18  19  20  21");
      System.out.println("  22  23  24  25  26  27  28");
      System.out.println("  29  30  ");
    }
  }
}

La classe di test TestCalendario.java

import java.util.Scanner;
public class TestCalendario
{
  public static void main(String[] args)
  {
    Scanner in = new Scanner(System.in);

    // Prendo in input l'anno
    System.out.println("Dammi l'anno :");
    int a = in.nextInt();

    // Prendo in input il mese
    System.out.println("Dammi il mese (numero): ");
    int m = in.nextInt();

    // Creo un oggetto Year e un oggetto Month
    Year ye = new Year(a);
    Month mo = new Month(ye,m);

    // Visualizzo i dati completi
    mo.getMonth();
    System.out.println(ye.getYear());
    mo.getDays();
  }
}