Programmazione per TWM: Esercitazione di laboratorio #15 (11/03)

Gli obiettivi di questa esercitazione sono: comprendere la differenza tra approccio procedurale o funzionale e approccio a oggetti per implementare un TDA; saper definire e utilizzare oggetti; comprendere l'uso della parola riservata this (capitolo 8 fino a 8.5 compreso).

Raccomandazioni: Ove non altrimenti indicato, rispondete alle domande prima ragionando su carta e poi provando a editare, compilare ed eseguire. Gli esercizi etichettati con l'asterisco (*) sono più difficili: affrontateli dopo aver risolto gli altri.

Esercizio 1

Obiettivo: saper trasformare un TDA implementato con approccio funzionale o procedurale in uno implementato con approccio a oggetti.

Attività:

Considerate il TDA CoppiaInt definito con approccio procedurale come segue:

class CoppiaInt {
  private int x;
  private int y;

  public CoppiaInt(int primo, int secondo) {
    x = primo;
    y = secondo;
  }

  public static int getPrimo(CoppiaInt c) {
    return c.x;
  }
  public static int getSecondo(CoppiaInt c) {
    return c.y;
  }
  public static void setPrimo(CoppiaInt c, int primo) {
    c.x = primo;
  }
  public static void setSecondo(CoppiaInt c, int secondo) {
    c.y = secondo;
  }
}

Completate (non è detto che al posto di proprio tutti i puntini vada messo qualcosa!!) la seguente versione con approccio a oggetti:

class OggettoCoppiaInt {
  private int x;
  private int y;

  public OggettoCoppiaInt(int a, int b) {
    x = a;
    y = b;
  }

  public int getPrimo(............) {
    return x;
  }
  public .... int getSecondo() {
    return ...;
  }
  ....... void setPrimo(........... primo) {
    x = primo;
  }
  public void setSecondo(int secondo) {
    ..........secondo;
  }
}

Aggiungere il metodo (d'istanza, non di classe) scambia, che scambia i valori delle due componenti tra di loro, alla classe OggettoCoppiaInt. Quanti parametri deve avere il metodo scambia nell'approccio a oggetti?
Scrivete il programma UsoOggettoCoppiaInt che crea due nuovi oggetti a e b di tipo OggettoCoppiaInt con valori letti da tastiera e poi stampa il primo componente di a e il secondo di b
Modificate UsoOggettoCoppiaInt aggiungendo, a fine programma, la seguente riga di codice:
```
System.out.println(OggettoCoppiaInt.getPrimo(a));
```
Aspettate a compilare! Vi sono errori? Perché? Verificate la vostra risposta provando a compilare.
Modificate UsoOggettoCoppiaInt aggiungendo, a fine programma, la seguente riga di codice:
```
System.out.println(OggettoCoppiaInt.getPrimo());
```
Aspettate a compilare! Vi sono errori? Perché? Verificate la vostra risposta provando a compilare.
Modificate la classe OggettoCoppiaInt aggiungendo il metodo public String toString() che restituisce una stringa della forma [x|y] per rappresentare la coppia con valori x e y. Se ad esempio l'oggetto a cui viene mandato il messaggio toString() ha le componenti x=12 e y=4, il metodo restituirà la stringa "[12|4]".
Modificate UsoOggettoCoppiaInt per far stampare a. Non dovete più usare getPrimo o getSecondo. Dovete usare toString, ma senza scriverlo...

Esercizio 2

Obiettivo: saper definire e usare oggetti.

Attività:

Definire l'oggetto Portafogli con i metodi
- aggiungiEuro per aggiungere un certo numero di euro al portafogli
- aggiungiLire per aggiungere un certo numero di lire al portafogli
- togliEuro per togliere un certo numero di euro dal portafogli (tenete presente che non si possono togliere soldi da un portafogli vuoto!)
- togliLire per togliere un certo numero di lire dal portafogli
- quantiSoldi per sapere quanto c'è nel portafogli. La somma restituita deve essere unica ed espressa in euro, anche se nel portafogli ci sono un po' di euro ed un po' di lire.
- alVerde per sapere se non ci sono più soldi nel portafogli.
Scegliere attentamente il tipo del risultato e il tipo e il numero dei parametri per ognuno dei metodi.
Un euro vale 1936,27 lire.
Scrivere il programma UsoPortafogli che crea un nuovo oggetto x di tipo Portafogli, per 4 volte chiede di inserire un numero di euro da tastiera da aggiungere al portafogli (non fate 4 assegnamenti!), poi chiede di inserire un numero di lire da aggiungere al portafogli, poi per 4 volte chiede di inserire un numero di lire da tastitiera da togliere al portafogli ed infine chiede di inserire un numero di euro da togliere al portafogli. Se non è al verde stampa "meno male!" e poi, in ogni caso, stampa il contenuto del portafogli.
Aggiungere a UsoPortafogli un array di n portafogli con n letto da tastiera. Scrivere un ciclo che, per ogni portafogli, chieda per 7 volte se si vogliono togliere o inserire soldi, se lo si vuole fare in euro o in lire ed infine chieda la somma che si vuole inserire o togliere dal portafogli.
Alla fine di tutte le operazioni il programma deve stampare il contenuto di tutti i portafogli.
L'output del programma deve essere simile a questo:
```
Quanti portafogli?
2
Portafogli 1
  (operazione 1) vuoi aggiungere o togliere [A/T]?
  A
  (operazione 1) in lire o euro [L/E]?
  L
  (operazione 1) quanto?
  12000
  (operazione 2) vuoi aggiungere o togliere [A/T]?
```
... dopo un po'...
```
  (operazione 7) quanto?
  3
Portafogli 2
  (operazione 1) vuoi aggiungere o togliere [A/T]?
```
... dopo un altro po'...
```
  (operazione 7) quanto?
  1000
  
 Dopo 7 operazioni 
   il Portafogli 1 contiene 34,72 euro
   il Portafogli 2 contiene 12,02 euro
```

Esercizio 3

Obiettivo: comprendere l'utilizzo della parola riservata this.

Attività:

Motificare OggettoCoppiaInt riscrivendo i metodi setPrimo e setSecondo con le intestazioni seguenti:
```
public void setPrimo(int x)
pubcli void setSecondo(int y)
```
Attenzione: dovete (eventualmente) modificare solo il corpo di questi due metodi. Nient'altro.
Modificare, a fine programma, UsoOggettoCoppiaInt per far modificare il primo componte di a e il secondo di b con dei numeri letti da tastiera e poi far stampare i due oggetti.
Funziona tutto come vi aspettavate?
Modificare OggettoCoppiaInt cambiando i nomi delle variabili private da x e y in a e b (ovvero cambiare private int x; in private int a; e analogamente per y).
Cos'altro deve essere modificato in OggettoCoppiaInt per far funzionare tutto come prima, se non si vuole cambiare l'intestazione dei metodi e del costruttore?
Verificate eseguendo di nuovo UsoOggettoCoppiaInt.
Aggiungere a OggettoCoppiaInt un costruttore senza parametri che, utilizzando il costruttore con 2 parametri, crea una coppia con entrambi i valori uguali a 1.
Modificare UsoOggettoCoppiaInt per far creare un oggetto c utilizzando il costruttore appena definito.
Far stampare c per controllare che tutto funzioni come ci si aspetta.

Esercizio 4

Obiettivo: saper definire e usare oggetti. Comprendere l'utilizzo della parola riservata this.

Attività:

L'oggetto ScacchieraScomoda è un TDA particolare con cui si possono memorizzare posizioni. Per occupare una casella della scacchiera occorre prima specificare la riga con un numero e la colonna con una lettera minuscola e poi utilizzare il metodo metti.
Aggiungere un opportuno costruttore con tre parametri alla classe Scacchiera qui di seguito. Il primo parametro dimensione (un intero ≤ di 26) specifica la dimensione della scacchiera, ossia il numero di righe e colonne, il secondo ed il terzo, rispettivamente riga e colonna, specificano la riga (un intero compreso tra 1 e la dimensione) e la colonna (una lettera) della cella attualmente selezionata. Alla successiva invocazione del metodo metti, la cella selezionata verrà occupata, oppure, se lo era già, verrà stampato a video il messaggio

"La 
    cella e' gia' occupata"

class ScacchieraScomoda {
  private boolean[ ][ ] dati;
  private int riga;
  private int colonna;
  private static final int DIMENSIONE_MASSIMA = 26;
  
  public ScacchieraScomoda(int dimensione, int riga, char colonna) {
  ...
  }
  
  public void metti() {
    if (dati[riga][colonna])
	  System.out.println("La cella e' gia' occupata");
	else
      dati[riga][colonna] = true;
  } 
  
  public String toString() {
    int dimensione = dati.length;
	String temp = "   ";
	for (int i = 0; i<2*dimensione+1; i++)
	  temp += "-";
	temp += "\n";
    for (int i = 0; i<dimensione; i++) {
	  temp += (dimensione-i<10?" ":"")+(dimensione-i)+" |";
	  for (int j = 0; j<dimensione; j++)
	    temp += (dati[(dimensione-i-1)][j]?"x":" ") + "|";
	  temp += "\n   ";
      for (int j = 0; j<2*dimensione+1; j++)
	    temp += "-";
	  temp += "\n";
	}
	temp += "    ";
	for (int i = 0; i<dimensione; i++)
	  temp += ((char)('a'+i)) + " ";
	return temp;
  }
}

Aggiungere il costruttore senza parametri ScacchieraScomoda() che crei una scacchiera di dimensione 8 con selezionata la cella 1,a. Il corpo del costruttore deve contenere una sola riga che consiste nella chiamata dell'altro costruttore.

Scrivere il programma UsoScacchieraScomoda che crei una scacchiera con il costruttore vuoto, chiami il suo metodo metti() e la stampi con System.out.println. L'output del programma deve essere quello qui sotto:

   -----------------
 8 | | | | | | | | |
   -----------------
 7 | | | | | | | | |
   -----------------
 6 | | | | | | | | |
   -----------------
 5 | | | | | | | | |
   -----------------
 4 | | | | | | | | |
   -----------------
 3 | | | | | | | | |
   -----------------
 2 | | | | | | | | |
   -----------------
 1 |x| | | | | | | |
   -----------------
    a b c d e f g h

Aggiungere il metodo d'istanza (non di classe!) selezionaCella(int riga, char colonna) che permette di selezionare un'altra cella.
Modificare UsoScacchieraScomoda in modo che crei una nuova scacchiera s2 di dimensione 2 ed occupi le celle di 1,a e 2,b di s2, dopo di che stampi s2. L'output del programma deve essere il seguente:
```
   -----
 2 | |x|
   -----
 1 |x| |
   -----
    a b 
```
(**) Modificare il toString di ScacchieraScomoda per visualizzarla con i + alle intersesioni tra righe e colonne. Ad esempio, la scacchiera al punto precedente dovrà essere visualizzata in questo modo:
```
   +-+-+
 2 | |x|
   +-+-+
 1 |x| |
   +-+-+
    a b 
```

Paolo Coppola
Last modified: 2003-03-27