Il Nuovo Java - Claudio De Sio Cesari

Esercizi

Home
Esercizi Capitolo 3

Capitolo 3
`Stile di codifica, tipi di dati ed array`

Di seguito una serie di esercizi per fare pratica con quanto appreso nel capitolo 3. Ricordiamo che molti esercizi sono propedeutici ai successivi, quindi non conviene saltarne qualcuno o quantomeno vi consigliamo di consultare le soluzioni prima di andare avanti.

Di seguito trovate gli esercizi del capitolo. Per ogni esercizio, cliccando sulla traccia potete vedere la relativa soluzione.
Gli esercizi caratterizzati dall'icona sono considerati i più complessi relativamente agli argomenti trattati.
Se preferite lavorare offline, è possibile scaricare tutti gli esercizi e le relative soluzioni in formato PDF nella sezione download.

Esercizio 3.a)
Scrivere un semplice programma che svolga le seguenti operazioni aritmetiche correttamente, scegliendo accuratamente i tipi di dati da utilizzare per immagazzinare i risultati di esse.

1. Una divisione (usare il simbolo /) tra due interi a = 5, e b = 3. Immagazzinare il risultato in una variabile r1, scegliendone il tipo di dato opportunamente.
2. Una moltiplicazione (usare il simbolo *) tra un char c = 'a', ed uno short s = 5000. Immagazzinare il risultato in una variabile r2, scegliendone il tipo di dato opportunamente.
3. Una somma (usare il simbolo +) tra un int i = 6 ed un float f = 3.14F. Immagazzinare il risultato in una variabile r3, scegliendone il tipo di dato opportunamente.
4. Una sottrazione (usare il simbolo -) tra r1, r2 e r3. Immagazzinare il risultato in una variabile r4, scegliendone il tipo di dato opportunamente.
Verificare la correttezza delle operazioni stampandone i risultati parziali e il risultato finale. Tenere presente la promozione automatica nelle espressioni, e utilizzare il cast opportunamente. È richiesta la creazione di una sola classe con un main che svolga le operazioni.
Soluzione

Di seguito viene listata una classe che aderisce ai requisiti richiesti:
```
public class Esercizio3A {
    public static void main(String args[]) {
      int a = 5, b = 3;
      double r1 = (double)a/b;
      System.out.println("r1 = " + r1);
      char c = 'a';
      short s = 5000;
      int r2 = c*s;
      System.out.println("r2 = " + r2);
      int i = 6;
      float f = 3.14F;
      float r3 = i + f;
      System.out.println("r3 = " + r3);
      double r4 = r1 – r2 – r3;
      System.out.println("r4 = " + r4);
  }
}
```
Esercizio 3.b)
Scrivere un programma con i seguenti requisiti:

1. Implementare una classe Persona che dichiari le variabili nome, cognome, eta (età). Si dichiari inoltre un metodo dettagli che restituisca in una stringa le informazioni sulla persona in questione.
Ricordarsi di utilizzare le convenzioni e le regole descritte in questo capitolo.
2. Implementare una classe Principale che, nel metodo main, istanzi due oggetti chiamati persona1 e persona2 della classe Persona, inizializzando per ognuno di essi i relativi campi utilizzando l’operatore dot.
3. Dichiarare un terzo reference (persona3) che punti ad uno degli oggetti già istanziati. Controllare che effettivamente persona3 punti all'oggetto voluto, stampando i campi di persona3 sempre mediante l’operatore dot.
4. Commentare adeguatamente le classi realizzate e sfruttare lo strumento javadoc per produrre la relativa documentazione.

Nella documentazione standard di Java sono usate tutte le regole e le convenzioni descritte in questo capitolo. Basta osservare che String inizia con lettera maiuscola, essendo una classe. Si può concludere che anche System è una classe.
Soluzione
```
public class Persona {
    public String nome;
    public String cognome;
    public int eta;
    public String dettagli() {
        return nome + " " + cognome + " anni " + eta;
    }
}
public class Principale {
    public static void main(String args []) {
        Persona persona1 = new Persona();
        Persona persona2 = new Persona();
        persona1.nome = "Mario";
        persona1.cognome = "Rossi";
        persona1.eta = 30;
        System.out.println("persona1 "+persona1.dettagli());
        persona2.nome = "Giuseppe";
        persona2.cognome = "Verdi";
        persona2.eta = 40;
        System.out.println("persona2 "+persona2.dettagli());
        Persona persona3 = persona1;
        System.out.println("persona3 "+persona3.dettagli());
    }
}
```
Esercizio 3.c) Array, Vero o Falso:

1. Un array è un oggetto e quindi può essere dichiarato, istanziato ed inizializzato.

2. Un array bidimensionale è un array i cui elementi sono altri array.

3. Il metodo length restituisce il numero degli elementi di un array.

4. Un array non è ridimensionabile.

5. Un array è eterogeneo di default.

6. Un array di interi può contenere come elementi byte, ovvero le seguenti righe di codice non producono errori in compilazione:
```
int arr [] = new int[2];
byte a = 1, b = 2;
arr [0] = a;
arr [1] = b;
```
7. Un array di interi può contenere come elementi char, ovvero le seguenti righe di codice non producono errori in compilazione:
```
char a = 'a', b = 'b';
int arr [] = {a,b};
```
8. Un array di stringhe può contenere come elementi char, ovvero le seguenti righe di codice non producono errori in compilazione:
```
String arr [] = {'a' , 'b'};
```
9. Un array di stringhe è un array bidimensionale, perché le stringhe non sono altro che array di caratteri. Per esempio:
```
String arr [] = {"a" , "b"};
```
è un array bidimensionale.

10. Se abbiamo il seguente array bidimensionale:
```
int arr [][]= {
{1, 2, 3},
{1,2},
{1,2,3,4,5}
};
```
risulterà che:
```
arr.length = 3;
arr[0].length = 3;
arr[1].length = 2;
arr[2].length = 5;
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 1;
arr[1][1] = 2;
arr[1][2] = 3;
arr[2][0] = 1;
arr[2][1] = 2;
arr[2][2] = 3;
arr[2][3] = 4;
arr[2][4] = 5;
```
Soluzione

1. Vero.
2. Vero.
3. Falso, la variabile length restituisce il numero degli elementi di un array.
4. Vero.
5. Falso.
6. Vero, un byte (che occupa solo 8 bit) può essere immagazzinato in una variabile int (che occupa 32 bit).
7. Vero, un char (che occupa 16 bit) può essere immagazzinato in una variabile int (che occupa 32 bit).
8. Falso, un char è un tipo di dato primitivo e String è una classe. I due tipi di dati non sono compatibili.
9. Falso, in Java la stringa è un oggetto istanziato dalla classe String e non un array di caratteri (anche se internamente alla classe, viene usato un array di caratteri).
10. Falso, tutte le affermazioni sono giuste tranne arr[1][2] = 3; perché questo elemento non esiste.

Esercizio 3.d)

Creare una classe StampaMioNome con un metodo main, che stampa il vostro nome usando un array di caratteri.

Soluzione

Il listato dovrebbe essere simile al seguente:

public class StampaMioNome {
    public static void main(String args[]) {
      char [] nome = {'C', 'l', 'a', 'u', 'd', 'i', 'o'};
      System.out.println(nome);
  }
}

Esercizio 3.e)
Creare una classe Risultato che dichiara una sola variabile d’istanza di tipo float di nome risultato. Aggiungere eventuali metodi e costruttori utili. Creare una classe CambiaRisultato che dichiara un metodo public di nome cambiaRisultato che prende in input un oggetto di tipo Risultato e ne modifica la variabile interna risultato sommandola con un altro valore. Creare una classe con un metodo main di nome TestRisultato che stampi la variabile risultato di un oggetto di tipo Risultato, prima e dopo che questo oggetto sia passato in input al metodo cambiaRisultato di un oggetto di tipo CambiaRisultato.
Soluzione

Il listato della classe Risultato potrebbe essere il seguente:
```
public class Risultato {
  public float risultato;

  public Risultato(float ris) {
      risultato = ris;
  }

  public void stampa() {
      System.out.println(risultato);
  }
}
```
Si noti che abbiamo creato un costruttore e un metodo di stampa di comodità.
Il listato della classe CambiaRisultato potrebbe essere il seguente:
```
public class CambiaRisultato {
  public void cambiaRisultato(Risultato risultato) {
    risultato.risultato += 1;
  }
}
```
Il listato della classe TestRisultato potrebbe essere il seguente:
```
public class TestRisultato {
    public static void main(String args[]) {
      Risultato risultato = new Risultato(5.0F);
      risultato.stampa();
      CambiaRisultato cr = new CambiaRisultato();
      cr.cambiaRisultato(risultato);
      risultato.stampa();
  }
}
```
L’output del precedente codice sarà:
```
5.0
6.0
```
Esercizio 3.f)
Dopo aver svolto l’esercizio precedente, aggiungere alla classe CambiaRisultato un metodo che si chiama sempre cambiaRisultato che però prende in input una variabile float e ne modifica il risultato.
Creare poi una classe TestRisultatoFloat equivalente, che esegua le stesse operazioni della classe TestRisultato realizzata nell’esercizio precedente.
Soluzione

Il listato della classe CambiaRisultato dovrebbe cambiare come segue:
```
public class CambiaRisultato {
  public void cambiaRisultato(Risultato risultato) {
    risultato.risultato += 1;
  }

  public float cambiaRisultato(float risultato) {
    risultato += 1;
    return risultato;
  }
}
```
Si noti che questa volta il metodo deve ritornare il nuovo valore della variabile trattandosi di una variabile di tipo primitivo (cfr. paragrafo 3.3).
Il listato della classe TestRisultatoFloat potrebbe essere il seguente:
```
public class TestRisultatoFloat {
  public static void main(String args[]) {
    float risultato = 5.0F;
    System.out.println(risultato);
    CambiaRisultato cr = new CambiaRisultato();
    risultato = cr.cambiaRisultato(risultato);
    System.out.println(risultato);
  }
}
```
Si noti che abbiamo dovuto riassegnare il valore della variabile risultato dopo la computazione del metodo cambiaRisultato.
Esercizio 3.g)
Creare una classe TestArgs con un metodo main che stampa la variabile args[0]. Quindi testarla passando vari input da riga di comando (cfr. paragrafo 3.6.7).
Soluzione

Il listato dovrebbe essere simile a:
```
public class TestArgs {
  public static void main(String args[]) {
    System.out.println(args[0]);
  }
}
```
Si noti che se non passate un argomento quando eseguite l’applicazione otterrete un’eccezione al runtime:
```
java TestArgs
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
	at TestArgs.main(TestArgs.java:3)
```
Le eccezioni sono trattate nel capitolo 8.
Esercizio 3.h)
La seguente classe dichiara vari identificatori di tipo stringa:
```
public class Esercizio3H {
  public String Break,
  String,
  character,
  bit,
  continues,
  exports,
  Class,
  imports,
  _AAA_,
  _@_,
  _;
}
```
Sono tutti validi? Una volta individuati quelli non validi, usare opportunamente i commenti per escluderli dalla compilazione.
Soluzione

Solo gli ultimi due identificatori non sono validi, infatti:

• L’identificatore Break è differente da break (tutte le parole chiave non hanno lettere maiuscole).
• L’identificatore String coincide con il nome della classe String, ma non essendo una parola chiave, è possibile utilizzarla come identificatore. Ciononostante si tratta di una cattiva pratica.
• L’identificatore character non è una parola chiave (lo è invece char).
• L’identificatore bit non è una parola chiave (lo è invece byte).
• L’identificatore continues non è una parola chiave (lo è invece continue).
• L’identificatore exports è una parola a utilizzo limitato, e sarebbe inutilizzabile all’interno della dichiarazione di un modulo, ma in questo contesto non crea problemi.
• L’identificatore Class non è una parola chiave (lo è invece class, vedi punto 1).
• L’identificatore imports non è una parola chiave (lo è invece import).
• L’identificatore _AAA_ non è una parola chiave.
• L’identificatore _@_ non è legale perché non si può usare il simbolo di chiocciola negli identificatori.
• L’identificatore _ è una parola riservata a partire da Java 9.

È possibile commentare i due identificatori non validi nel seguente modo:
```
public class Esercizio3H {
    public String Break,
    String,
    character,
    bit,
    continues,
    exports,
    Class,
    imports,
    _AAA_/*,
    _@_,
    _*/;
}
```
Abbiamo utilizzato un commento su più righe per commentare solo ciò che va commentato. Chiaramente questo approccio va a discapito della leggibilità del codice. Il modo più opportuno per commentare richiede il cambio del simbolo di "," con il simbolo ";" subito dopo la dichiarazione dell’identificatore _AAA_, e l'utilizzo del commento a singola riga:
```
public class Esercizio3H {
  public String Break,
  String,
  character,
  bit,
  continues,
  exports,
  Class,
  imports,
  _AAA_;
//    _@_,
//    _;
}
```

Esercizio 3.i)

Data la seguente classe:

package com.claudiodesio.manuale.esercizi;

public class Esercizio3I {
  public final String nomeLinguaggio = "Java 17";
  public int intero;
  public void stampaStringa() {
      System.out.println(nomeLinguaggio);
  }
}

C’è qualche convenzione non rispettata per i nomi? Se si, quale e come modificare per risolvere? Se non si rispettano le convenzioni dei nomi, il codice non compila?

Soluzione

L’unica convenzione non utilizzata correttamente è quella per la costante (si ricorda che le convenzioni non influiscono sulla compilabilità del codice).
Il codice andrebbe corretto nel seguente modo:

package com.claudiodesio.manuale.esercizi;

public class Esercizio3ISoluzione {
  public final String NOME_LINGUAGGIO = "Java 17";
  public int intero;
  public void stampaStringa() {
      System.out.println(NOME_LINGUAGGIO);
  }
}

Esercizio 3.j)

Considerando l’esercizio 1.y, creare una classe chiamata StampaClasseRigaVuota che stampi il seguente ouput:

public class RigaVuota {
    public static void main(String args[]) {
          System.out.println("");
      }
  }

Soluzione

Il problema sorge per la stampa delle virgolette definite all’interno del metodo println. La soluzione consiste nell’utilizzare i caratteri di escape:

public class StampaClasseRigaVuota {
    public static void main(String args[]) {
      System.out.println("public class RigaVuota {");
      System.out.println("    public static void main(String args[]) {");
      System.out.println("        System.out.println(\"\");");
      System.out.println("    }");
      System.out.println("}");
  }
}

Esercizio 3.k)
Data la seguente classe:
```
public class Esercizio3K {
    public static void main(String args[]) {
      char d = (char)100;
      float f = (float)d*1_000_000_000;
      System.out.println((long)f);
  }
}
```
Quale dei seguenti output produrrà una volta eseguita?

1. Nessuno, avremo un errore in compilazione per un errore di sintassi alla seconda riga del metodo main.
2. Un numero imprecisato.
3. 100000000000
4. 100_000_000_000
5. 100.000.000.000
6. 100,000,000,000
7. 66000000000
8. 0.0
9. Un carattere Unicode non prevedibile.
10. Il codice compila ma al runtime avremo una eccezione alla prima riga del metodo main perché non è possibile fare un cast di un int in un char.
11. Il codice compila ma al runtime avremo una eccezione alla seconda riga del metodo main perché non è possibile fare un cast di un int in un float.
12. Il codice compila ma al runtime avremo una eccezione alla terza riga del metodo main perché non è possibile fare un cast di un float in un long.
13. Il codice non compila per altre ragioni.
14. Il codice va in eccezione al runtime per altre ragioni.
Soluzione

Il codice compila, viene eseguito senza errori e stampa:
```
99999997952
```
ovvero, un numero imprecisato. Infatti i tipi float, per causa delle limitazioni dello standard IEEE-754, superate le 9 cifre decimali usa dei numeri approssimati (vedi paragrafo 3.3.2.1). La risposta giusta è quindi al numero 2.
Esercizio 3.l)
Data la seguente classe:
```
public class Esercizio3L {
    public static void main(String args[]) {
      bit i1 = 8;
      short i2 = -1024;
      integer i3 = 638;
      long i5 = 888_666_777;
      float i6 = 0;
      double i7 = 0x11B;
  }
}
```
Le variabili all’interno del metodo main sono tutte dichiarate correttamente? E i valori assegnati sono tutti entro l’intervallo di rappresentazione dei rispettivi tipi?
Soluzione

I tipi bit e integer non esistono (semmai esistono byte e int). Tutti i valori dichiarati rientrano nei rispettivi intervalli di rappresentazione, compreso il valore 0x11B che vale 283.0 per il sistema decimale e che, essendo immagazzinato in un double, è assolutamente compatibile.
Esercizio 3.m)
Data la seguente classe:
```
public class Esercizio3M {
    public static void main(String args[]) {
      boolean b = true;
      char c = 'I';
      System.out.println(b);
      System.out.println(c+1);
  }
}
```
Tenendo presente che la lettera I, è codificata tramite il numero decimale 73, quale dei seguenti output produrrà una volta eseguita?

1. Nessuno, avremo un errore in compilazione.
2. true alla prima riga e 74 alla seconda.
3. true alla prima riga e L alla seconda.
4. true alla prima riga e J alla seconda.
5. 0 alla prima riga e 74 alla seconda.
6. 0 alla prima riga e J alla seconda.
7. 0 alla prima riga e L alla seconda.
Soluzione

La risposta giusta è la numero 2. Infatti un literal booleano verrà stampato esattamente con il suo valore literal (true in questo caso). Invece c+1 viene promosso a numero intero, e da 73 diventa 74. Per potergli far stampare il valore carattere relativo (J) bisognerebbe fare un cast su tutta l’operazione in questo modo:
```
System.out.println((char)(c+1));
```
Esercizio 3.n)
Data la seguente classe:
```
public class Esercizio3N {
    public static void main(String args[]) {
      String s = "Jav";
      char c = "a";
      System.out.println(s+c+1);
  }
}
```
quale dei seguenti output produrrà una volta eseguita?
1. Nessuno, avremo un errore in compilazione.
2. Java
3. Java1
4. Javb
Soluzione

Avremo un errore in compilazione perché il valore assegnato al carattere c, è una stringa (si notino le virgolette al posto degli apici).
Esercizio 3.o)
Data la classe:
```
package parcheggio;

public class Auto {
  public String tipo;
  
  public Auto(String t) {
      tipo = t;
  }
}
```
Affinché la seguente classe compili:
```
package lavoratori;
//Inserisci il codice qui

public class Autista {
    public void guida(Auto auto) {
        System.out.println("Sto guidando l'auto " + auto.tipo);
    }
}
```
Bisogna inserire una riga di codice. Quale (o quali, potrebbero essere valide anche più di una) tra le seguenti righe permetterebbe alla classe Autista di essere compilata?

1. import parcheggio.Auto;
2. import parcheggio.*;
3. import parcheggio.lavoratori.*;
4. import parcheggio.Auto.*;
5. import parcheggio.*.Auto;
6. import lavoratori.parcheggio.Auto;
Soluzione

Le risposte corrette sono la 1 e la 2, tutte le altre sono scorrette a livello sintattico.
Esercizio 3.p)
Considerando le classi Auto e Autista dell’esercizio precedente, che pezzo di codice bisogna aggiungere alla seguente classe:
```
public class Esercizio3P {
//Inserisci il codice qui

public static void main(String args[]) {
    Auto auto = new Auto("Toyota Yaris");
    Autista autista = new Autista();
    autista.guida(auto);
  }
}
```
Scegliere una delle seguenti opzioni:
1. import parcheggio.*;
2. import lavoratori.*;
3. import parcheggio.Auto; e import lavoratori.Autista;
4. Non bisogna aggiungere codice. Il codice è già compilabile.
Soluzione

La risposta corretta è la 3 perché sono state utilizzate nel codice entrambe le classi Auto e Autista.
Esercizio 3.q)
La seguente affermazione è corretta? Quando passiamo un reference di un oggetto in input ad un metodo, siamo sicuri che terminata l’esecuzione del metodo, il nostro reference continuerà a puntare sempre allo stesso oggetto a cui puntava prima dell’esecuzione del metodo. Questo non significa che la struttura interna dell’oggetto, non possa essere modificata all’interno del metodo. Infatti il parametro locale del metodo, assumerà lo stesso indirizzamento del reference passato, e potrà quindi lavorare sullo stesso oggetto.

Soluzione

Sì, il ragionamento è corretto.
Esercizio 3.r)
Scrivere un programma che prenda in input un argomento (variabile args del metodo main) e lo immagazzini come terzo elemento di un array di stringhe locale chiamato per l’appunto array.

Questo programma funzionerà solo se viene passato almeno un argomento. Eventuali parametri passati da riga di comando oltre al primo, saranno ignorati dal programma.
Soluzione

Il listato dovrebbe essere simile a:
```
public class Esercizio3R {
    public static void main(String args[]) {
      String[] array = new String[5];
      array[2] = args[0];
  }
}
```

Esercizio 3.s)

Data la classe:

public class Auto {
  public String tipo;
    
  public Auto(String t) {
      tipo = t;
  }
}

Creare una classe Nave che astragga il concetto di nave che carica automobili. Questa classe deve definire un metodo caricaAuto a cui sarà passato un oggetto Auto. Ogni oggetto auto verrà immagazzinato in una variabile d’istanza array chiamata autoArray, nel primo posto disponibile dell’array. Creare anche una classe di test che è possibile chiamare Esercizio3S.

Soluzione

Il codice richiesto dovrebbe essere simile al seguente:

public class Nave {

    int indice = 0;
    public Auto[] autoArray;

    public Nave() {
        autoArray = new Auto[100];
    }

    public void caricaAuto(Auto auto) {
        autoArray[indice] = auto;
        System.out.println("Auto: " + auto.tipo + " caricata");
        indice++;
    }
}

Dove abbiamo usato un indice per tenere traccia delle posizioni già occupate nella nave. Questo viene incrementato ogni volta che viene caricata un'auto, e poi sfruttato per caricare la prossima. La seguente classe di test soddisfa la richiesta:

public class Esercizio3S {
  public static void main(String args[]) {
    Nave nave = new Nave();
    Auto auto1 = new Auto("Renault");
    Auto auto2 = new Auto("Volkswagen");
    Auto auto3 = new Auto("Nissan");
    nave.caricaAuto(auto1);
    nave.caricaAuto(auto2);
    nave.caricaAuto(auto3);
  }
}

Esercizio 3.t)
Creare un programma Esercizio3T che deve essere eseguito passando un parametro da riga di comando rappresentante un numero intero, nel seguente modo:
```
java Esercizio3T 9
```
Con EJE è possibile passare parametri con la scorciatoia di tastiera "Maiuscolo - F9", ovvero con il menu "esegui con argomenti" ("execute with args").

Si può sostituire il numero intero 9 con un qualsiasi altro numero intero.
Il programma dovrà:

• utilizzare args[0], che contiene un numero intero, per creare un array di interi della stessa dimensione dell’argomento;
• stampare una frase che confermerà la creazione dell’array, stampandone la dimensione.

Visto che i parametri vengono immagazzinati negli elementi dell’array di stringhe args, bisogna convertire il parametro passato in input da stringa ad intero. Cercare nella libreria il metodo parseInt della classe Integer. Leggere la documentazione, capire come funziona ed utilizzarlo nel programma.

Nel caso ci si trovi in difficoltà si esegua una ricerca su Google per cercare aiuto, il web è pieno di soluzioni.
Soluzione

Il listato richiesto dovrebbe essere simile al seguente:
```
public class Esercizio3T {
    public static void main(String args[]) {
      int dimensioneArray = Integer.parseInt(args[0]);
      int [] array = new int[dimensioneArray];
      System.out.println("L'array ha dimensione " + array.length);
  }
}
```
Si noti che il metodo parseInt è statico (argomento non ancora affrontato) e può essere utilizzato con la sintassi: nomeClasse.parseInt, ma è possibile anche istanziare un oggetto e invocarlo come un normale metodo (ma è inutile istanziare l’oggetto).
Esercizio 3.u)
Creare un programma che:

• crei un array di tipi carattere, con tutte le lettere dell’alfabeto;
• utilizzi un metodo (statico) della classe java.util.Arrays per stampare il suo contenuto sotto forma di stringa. Cercare nella documentazione ufficiale il metodo adatto allo scopo.

Nel caso ci si trovi in difficoltà si esegua una ricerca su Google per cercare aiuto, il web è pieno di soluzioni.
Soluzione

Il listato richiesto dovrebbe essere simile al seguente:
```
import java.util.Arrays;

public class Esercizio3U {
  public static void main(String args[]) {
      char[] array = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
        'i', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'z'};
      System.out.println(Arrays.toString(array));
  }
}
```
Il metodo toString della classe Arrays era il metodo richiesto. Per utilizzarlo è necessario importare la classe Arrays.
Esercizio 3.v)
Creare una classe con metodo main, che quando viene lanciata, stampi un numero casuale di tipo intero.

Suggerimento: esiste un metodo di una classe nella libreria Java che fa esattamente questo. Per trovarlo, si parta dal tradurre in inglese la parola "casuale" e si cerchi nella documentazione.
Soluzione

Il listato richiesto dovrebbe essere simile al seguente:
```
import java.util.Random;

public class Esercizio3V {
  public static void main(String args[]) {
      Random random = new Random();
      System.out.println(random.nextInt());
  }
}
```
Esercizio 3.w)
Data la seguente classe:
```
public class Esercizio3W {
    public static void main(String args[]) {
      var var = "var";
      var a = " ";
      var b = " = ";
      var c = 8;
      var d = ";";
      var e = c + d;
      System.out.println(var + a + "i" + b + c +d);
  }
}
```
È possibile compilare questa applicazione?

1. No, avremo un errore in compilazione per un errore di sintassi alla prima riga del metodo main.
2. No, avremo un errore in compilazione per un errore di sintassi alla seconda riga del metodo main.
3. No, avremo un errore in compilazione per un errore di sintassi alla terza riga del metodo main.
4. No, avremo un errore in compilazione per un errore di sintassi alla quarta riga del metodo main.
5. No, avremo un errore in compilazione per un errore di sintassi alla quinta riga del metodo main.
6. No, avremo un errore in compilazione per un errore di sintassi alla sesta riga del metodo main.
7. No, avremo un errore in compilazione per un errore di sintassi alla settima riga del metodo main.
8. Sì.
Soluzione

La classe Esercizio3W verrà compilata correttamente e quando eseguita stamperà:
```
var i = 8;
```

Esercizio 3.x)

Nella classe Rubrica sostituire le tre variabili d’istanza contatto1, contatto2 e contatto3 con un array e modificare la classe StampaContatti di conseguenza. Riscrivere la soluzione dell’Esercizio 2.y, utilizzando la parola var, ovunque sia possibile usarla.

Soluzione

Possiamo sostituire le variabili d’istanza della classe Rubrica con un array, utilizzando il seguente codice:

public class Rubrica {
  public Contatto[] contatti;
  public Rubrica () {
    contatti = new Contatto[]{
      new Contatto("Claudio De Sio Cesari", "Via Java 13", "131313131313"),
      new Contatto("Stevie Wonder", "Via Musica 10", "1010101010"),
      new Contatto("Gennaro Capuozzo", "Piazza Quattro Giornate 1",
       "1111111111")};
  }
}

Che è equivalente a utilizzare la sintassi ordinaria dell’array:

public class Rubrica {
    public Contatto[] contatti;
    public Rubrica () {
        contatti = new Contatto[3];
        contatti[0] = new Contatto("Claudio De Sio Cesari", "Via Java 13",
            "131313131313");
        contatti[1] = new Contatto("Stevie Wonder", "Via Musica 10", 
            "1010101010");
        contatti[2] = new Contatto("Gennaro Capuozzo", 
           "Piazza Quattro Giornate 1", "1111111111");
    }
}

Per quanto riguarda l’introduzione della parola var, nelle classi Contatto e Rubrica, non essendo definita alcuna variabile locale, non è possibile utilizzare la parola var, quindi tali classi non vanno modificate. La classe StampaContatti essere modificata in questo modo:

public class StampaContatti {
    public static void main(String args[]) {
        System.out.println("Elenco Contatti");
        System.out.println();
        var rubrica = new Rubrica();
        rubrica.contatti[0].stampaDettagli();
        rubrica.contatti[1].stampaDettagli();
        rubrica.contatti[2].stampaDettagli();
    }
}

Esercizio 3.y)
Quali dei seguenti snippet può essere compilato senza errori:

1. public class var {}
2. private class var {}
3. public var MiaClasse {}
4. var var[] = new int[8];
5. public var var = 1;

Soluzione

Nessuno snippet è corretto. I numeri 1 e 2 riportano classi con identificatore var, ma non è possibile utilizzare la parola var come identificatore per i tipi (vedi paragrafo 3.7.2). Inoltre nel caso dello snippet numero 2, non è neanche possibile utilizzare la parola chiave private per definire una classe (lo vedremo meglio nei prossimi capitoli). Nello snippet 3, c’è una sintassi che prova a definire una classe usando la parola chiave var al posto della parola chiave class, ma non è questa la funzione per cui è stata creata la parola var. Nel quarto snippet si prova ad utilizzare la parola var come identificatore di un array, ma sempre nel paragrafo 3.7.2, viene specificato chiaramente che questo è illegale. Infine nello snippet numero 5, possiamo dedurre dalla presenza del modificatore public, che si tratta di una definizione di una variabile d’istanza e non di una variabile locale, e quindi l’utilizzo della parola var non è consentito.

Esercizio 3.z)

Creare una classe Pagella che astragga il concetto di pagella scolastica. Essa deve avere le seguenti informazioni:

• nome, cognome e classe dell’alunno;
• una tabella che associ per ogni materia, il voto e il giudizio.

Deve inoltre dichiarare un metodo che stampi in maniera leggibile i dati della pagella.
Creare anche una classe Esercizio3Z che stampi una o più pagelle.

Soluzione

Decidiamo di creare un’astrazione per la classe Studente:

public class Studente {
    public String nome;
    public String cognome;
    public String classe;

    public Studente(String nom, String cog, String cla) {
        nome = nom;
        cognome = cog;
        classe = cla;
    }

    public String toString() {
        return "Studente: " + nome + " " + cognome + "\nClasse " + classe;
    }
}

Abbiamo dichiarato le informazioni essenziali (richieste dalla traccia dell’esercizio) e abbiamo creato un costruttore per impostare queste informazioni. Abbiamo anche creato un metodo toString che restituisce una stringa descrittiva dell’oggetto.

Vedremo più avanti che questo metodo sarà utilizzato spessissimo nella programmazione Java, perché già presente in ogni classe.

Poi creiamo una classe Pagella che astrae il concetto di tabella:

import java.util.Arrays;

public class Pagella {
  public Studente studente;
  public String[][] tabellaVoti;

  public Pagella(Studente stu, String [][] tab) {
      studente = stu;
      tabellaVoti = tab;        
  }

  public void stampaPagella() {
      System.out.println(studente.toString());
      System.out.println(Arrays.toString(tabellaVoti[0]));
      System.out.println(Arrays.toString(tabellaVoti[1]));
      System.out.println(Arrays.toString(tabellaVoti[2]));
      System.out.println(Arrays.toString(tabellaVoti[3]));
      System.out.println(Arrays.toString(tabellaVoti[4]));
      System.out.println(Arrays.toString(tabellaVoti[5]));
      System.out.println(Arrays.toString(tabellaVoti[6]));
  }
}

Si noti che questa classe dichiara un oggetto studente e un array bidimensionale tabellaVoti, entrambi da impostare quando si istanzia l’oggetto con il costruttore fornito. Inoltre dichiara il metodo stampaPagella che usa il metodo statico toString della classe java.util.Arrays per formattare il contenuto di ogni "riga" dell’array bidimensionale tabellaVoti.
Infine con la seguente classe, andiamo a stampare due pagelle:

public class Esercizio3Z {
  public static void main(String args[]) {
    Studente studente1 = new Studente("Giovanni","Battista","5A");
    String [][] tabellaVoti1 = {
        {"Italiano","7","Non si impegna troppo."},
        {"Matematica","9","È molto portato per questa materia."},
        {"Storia","7","Potrebbe fare di più."},
        {"Geografia","8","Appassionato."},
        {"Inglese","9", "Capace di sostenere dialoghi."},
        {"Scienze Motorie","6", "Voto d'incoraggiamento."},
        {"Musica","7", "Ha una certa passione per la materia."}
    };
    Pagella pagella1 = new Pagella(studente1, tabellaVoti1);

    Studente studente2 = new Studente("Daniele","Sapore","2A");
    String [][] tabellaVoti2 = {
        {"Italiano","8","Manifesta entusiasmo per la materia."},
        {"Matematica","5","Per niente interessato."},
        {"Storia","6","Interessato, ma si impegna poco."},
        {"Geografia","6","Potrebbe fare di più."},
        {"Inglese","8", "Ottima pronuncia."},
        {"Scienze Motorie","7", "Un po' pigro."},
        {"Musica","9", "Suona diversi strumenti ed ha un'ottima voce."}
    };
    Pagella pagella2 = new Pagella(studente2, tabellaVoti2);
    
    pagella1.stampaPagella();
    pagella2.stampaPagella();
  }
}

L’output è il seguente:

Studente: Giovanni Battista
Classe 5A
[Italiano, 7, Non si impegna troppo.]
[Matematica, 9, È molto portato per questa materia.]
[Storia, 7, Potrebbe fare di più.]
[Geografia, 8, Appassionato.]
[Inglese, 9, Capace di sostenere dialoghi.]
[Scienze Motorie, 6, Voto d'incoraggiamento.]
[Musica, 7, Ha una certa passione per la materia.]
Studente: Daniele Sapore
Classe 2A
[Italiano, 8, Manifesta enstusiamo per la materia.]
[Matematica, 5, Per niente interessato.]
[Storia, 6, Interessato, ma si impegna poco.]
[Geografia, 6, Potrebbe fare di più.]
[Inglese, 8, Ottima pronuncia.]
[Scienze Motorie, 7, Un po' pigro.]
[Musica, 9, Suona diversi strumenti ed ha un'ottima voce.]

Esercizio 3.aa)
Creare una classe CalcolaAreaTriangolo, che calcola l’area di un triangolo che abbia come base il valore 3.8, come altezza il valore 5.4, e ne stampi il risultato. Usare solo una classe con metodo main, che dichiari delle variabili in maniera leggibile.

È possibile anche settare i valori delle variabili tramite un oggetto Scanner.
Soluzione

Una soluzione potrebbe essere la seguente:
```
public class CalcolaAreaTriangolo {
  public static void main(String args[]) {
    double base = 3.8;
    double altezza = 5.4;
    double areaTriangolo = (base * altezza)/2;
    System.out.println("L'area del triangolo è:"); 
    System.out.println(areaTriangolo);
  }
}
```
Il cui output sarà:
```
L'area del triangolo è:
  10.26
```
Notare che le variabili double, possono avere come valore un numero decimale (notare che al posto della virgola viene utilizzato un punto, perché questo è lo standard negli Stati Uniti).
Non è possibile però assegnare un numero decimale ad una variabile di tipo int, per esempio l’istruzione:
```
int base = 3.8;
```
provocherebbe il seguente errore in compilazione:
```
error: incompatible types: possible lossy conversion from double to int
          int base = 3.8;
                     ^
  1 error
  
```

Email

Potete usare questo form per mandare all'autore richieste, suggerimenti, segnalazioni di errori, refusi, pareri, critiche, complimenti o altro.

Potete anche mandare una email direttamente all'indirizzo claudio@claudiodesio.com.

Il tuo messaggio è stato inviato correttamente. Grazie!

Esercizi

Capitolo 3Stile di codifica, tipi di dati ed array

Email

Capitolo 3
`Stile di codifica, tipi di dati ed array`