nuovo java

Soluzione

Di seguito viene listata una classe che aderisce ai requisiti richiesti:

public class TestPari {
  public static void main(String args[]) {
    int i = 0;
    while (true) {
        i++;
        if (i > 10)
            break;
        if ((i % 2) != 0)
            continue;
        System.out.println(i);
    }
  }
}

2
4
6
8
10

Soluzione

public class TestArray {
    public static void main(String args[]) {
        for (int i = 0; i < 26; ++i) {
            char c = (char)('a' + i);
            System.out.println(c);
        }
    }
}

Soluzione

Il listato potrebbe essere il seguente:

public class Tabelline {
    public static void main(String args[]) {
        for (int i = 1; i <= 10; ++i) {
            for (int j = 1; j <= 10; ++j) {
                System.out.print(i*j + "\t");
            }
            System.out.println();
        }
    }
}

Soluzione

1. Vero.
2. Vero.
3. Falso, la variabile booleana flag avrà valore true. Le espressioni atomiche valgono rispettivamente true-false-true, sussistendo le seguenti uguaglianze: i = 6, j = 7, k = 5, h = 6. Infatti (i != j) vale true e inoltre (i <= h) vale true. L' espressione ( (j <= k ) || (i <= h)) ) vale true, sussistendo l'operatore OR. Infine l'operatore AND fa sì che la variabile flag valga true.
4. Vero.
5. Falso, switch può testare solo una variabile intera (o compatibile) confrontandone l'uguaglianza con costanti (in realtà dalla versione 5 si possono utilizzare come variabili di test anche le enumerazioni e il tipo Integer, e dalla versione 7 anche le stringhe). Il costrutto if permette di svolgere controlli incrociati sfruttando oggetti, espressioni booleane etc.
6. Falso, l'operatore ternario è equivalente ad un'espressione che restituisce un valore. In particolare produce sempre un valore, e questo deve essere per forza assegnato o utilizzato in qualche modo (assegnandolo ad una variabile, passandolo come argomento ad un metodo, etc.). Per esempio, se i e j sono due interi, la seguente espressione: i < j ? i : j; provocherebbe un errore in compilazione (oltre a non avere senso), visto che il risultato non viene sfruttato.
7. Vero.
8. Falso, il do in qualsiasi caso garantisce l'esecuzione della prima iterazione sul codice. Il while potrebbe prescindere da questa soluzione.
9. Falso, lo switch è una condizione non un ciclo.
10. Falso, il continue non si può utilizzare nello switch ma solo nei cicli.

Soluzione

Il listato potrebbe essere il seguente:

public class TestArgs {
    public static void main(String args[]) {
        if (args.length == 1) {
            System.out.println(args[0]);
        } else {
            System.out.println("Specificare un valore da riga di comando");
        }
    }
}

Soluzione

Questo perché non sappiamo a priori come si evolverà il nostro programma, e quindi, anche se nel momento in cui si scrive il programma potrebbe non essere necessario la clausola default, modificando il programma potrebbe nascere una nuova condizione non prevista, creando un baco nella nostra applicazione. Infatti il nuovo caso non sarà contemplato e il flusso di esecuzione non entrerà in nessuna clausola del costrutto switch. Anche usare il costrutto default solo per stampare una frase "Caso non previsto" potrebbe essere una buona abitudine.

Soluzione

La risposta è identica alla precedente. La clausola else per un if è equivalente a una clausola default per lo switch.

Soluzione

Il listato richiesto potrebbe essere il seguente:

public class Esercizio4H {
    public static void main(String args[]) {
        for (int i = 1, j = 1; j <= 10; i++) {
            if (i % 3 == 0) {
                System.out.println("Numero multiplo di 3 = " + i);
                j++;
            }
        }
    }
}

Soluzione

Il listato richiesto potrebbe essere il seguente:

public class Esercizio4I {
    public static void main(String args[]) {
        int i = 1, j = 1;
        while (j <= 10) {
            if (i % 3 == 0) {
                System.out.println("Numero multiplo di 3 = " + i);
                j++;
            }
            i++;
        }
    }
}

Soluzione

Il listato richiesto potrebbe essere il seguente:

public class Esercizio4J {
    public static void main(String args[]) {
        int i = 1, j = 1;
        do {
            if (i % 3 == 0) {
                System.out.println("Numero multiplo di 3 = " + i);
                j++;
            }
            i++;
        } while(j <= 10);
    }
}

Soluzione

Il codice della classe PariODispari richiesto potrebbe essere il seguente:

import java.util.*;

public class PariODispari {
    public String dammiPariODispari() {
        Random random = new Random();
        return random.nextInt() % 2 == 0 ? "Pari" : "Dispari";
    }
}

Mentre il codice della classe che TestPariODispari potrebbe essere il seguente:

public class PariODispariTest {
    public static void main(String args[]) {
        PariODispari pariODispari = new PariODispari();
        System.out.println(pariODispari.dammiPariODispari());
    }
}

Soluzione

Il codice della classe TestaOCroce richiesto potrebbe essere il seguente:

public class TestaOCroce {
    public String dammiTestaOCroce() {
        PariODispari pariODispari = new PariODispari();
        String pariODispariString = pariODispari.dammiPariODispari();
        String testaOCroce = switch (pariODispariString) {
            case "Pari" -> "Testa";
            case "Dispari" -> "Croce";
            default -> "C'è un Bug!!!";
        };
        return testaOCroce;
    }
}

mentre il codice della classe che TestaOCroceTest potrebbe essere il seguente:

public class TestaOCroceTest {
    public static void main(String args[]) {
        TestaOCroce testaOCroce = new TestaOCroce();
        System.out.println(testaOCroce.dammiTestaOCroce());
    }
}

Soluzione

Il listato richiesto potrebbe essere il seguente:

import java.util.Scanner;

public class Moderatore {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        String stringa = "";
        System.out.println("Digita qualcosa e batti enter, oppure scrivi "
          + "\"fine\" per terminare il programma");
        while (!(stringa = scanner.next()).equals("fine")) {
            stringa = moderaStringa(stringa);
            System.out.println("Hai digitato " + stringa.toUpperCase() + "!");
        }
        System.out.println("Fine programma!");
    }

    private static String moderaStringa(String stringa) {
        switch (stringa) {
            case "accipicchiolina":
            case "perbacco":
            case "stupidino":
            case "giulivo":
            case "giocondo":
            case "perdindirindina":
                stringa = "CENSURATA!";
                break;
            default:
                break;
        }
        return stringa;
    }
}

Soluzione

Elenchiamo tutti i casi:

1. + se inteso come operatore di addizione no, ma come operatore di concatenazione di stringhe permette di concatenare una stringa a un booleano.
2. % no
3. ++ no
4. /= no
5. & sì, per esempio (true & false) = true.
6. = sì, è un operatore di assegnazione, applicabile a qualsiasi tipo.
7. !! non è un operatore.
8. >>> no

Soluzione

La risposta corretta è: 99.
Infatti i inizialmente vale 99. Poi nella condizione del primo if, viene usato un operatore di post-incremento, il quale avendo minore priorità rispetto all'operatore >= viene eseguito dopo di esso. Questo implica che i vale ancora 99 quando viene testato se è >= 100, e solo dopo il test viene incrementato a 100. Quindi la condizione dell'if è false, e non viene eseguito il relativo blocco di codice. Quindi viene eseguito il blocco di codice della clausola else. Qui viene stampato il risultato di un operatore ternario. Infatti viene decrementato il valore di i da 100 a 99, e quindi l'operatore ternario ritorna il primo valore, ovvero i++. Anche in questo caso si tratta di un operatore di post-incremento (a bassa priorità), e quindi viene prima stampato il valore di i (99) e poi incrementata la variabile (ma tanto il programma termina subito dopo).

Soluzione

La risposta corretta è: 32 e al rigo successivo 2, ovvero l'output è il seguente:

32
2

Infatti inizialmente i vale 22, e j vale quanto il resto di 22 (e non 23 perché il post-incremento viene applicato dopo l'operatore modulo %) diviso 3, ovvero 1. Dopodiché ad i viene assegnato il valore di ritorno dell'operatore ternario che controlla se j!=0 (e lo è). Quindi viene ritornato il valore di j che è 1. Nel costrutto switch si entra nel case 1 dove viene stampato 8<<2, che equivale a 8 moltiplicato per 2 alla seconda, ovvero 32. Inoltre viene eseguito anche il case 0, visto che non c'è un break che fa uscire dal costrutto. Quindi viene stampato 8>>2 che equivale a 8 diviso 2 alla seconda, ovvero 2.

Soluzione

Il listato potrebbe essere il seguente:

import java.util.Scanner;

public class Esercizio4Q {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Digita il numero di giorni passati dall'ultima vacanza");
        int giorni = scanner.nextInt();
        System.out.println("Hai digitato " + giorni + " giorni!");
        int ore = giorni*24;
        int minuti = ore*60;
        System.out.println("Quindi sono passati " + minuti + " minuti!");
    }
}

Soluzione

La soluzione potrebbe essere la seguente:

public class Esercizio4R {

    private static int matrice[][] = {
        {1, 7, 3, 9, 5, 3},
        {6, 2, 3},
        {7, 5, 1, 4, 0},
        {1, 0, 2, 9, 6, 3, 7, 8, 4}
    };

    public static void main(String args[]) {
        int numeroDaTrovare = Integer.parseInt(args[0]);
        PRIMA_LABEL:
        for (int i = 0; i < matrice.length; i++) {
            int[] riga = matrice[i];
            for (int j = 0; j < riga.length; j++) {
                if (riga[j] == numeroDaTrovare) {
                    System.out.println(numeroDaTrovare +" trovato a riga = "
                        + ++i + ", colonna = " + ++j);
                    break PRIMA_LABEL;
                }
            }
        }
        System.out.println("Ricerca terminata");
    }
}

Abbiamo dapprima dovuto convertire args[0] tramite il metodo statico della classe Integer parseInt (cfr. esercizio 3.t) immagazzinandolo in una variabile numeroDaTrovare. Poi abbiamo utilizzato un doppio ciclo innestato per navigare all'interno delle celle della matrice, sfruttando gli indici i (per le righe) e j (per le colonne). Si noti l'utilizzo della label che abbiamo chiamato PRIMA_LABEL, che marca il ciclo esterno. Quando viene trovata la prima occorrenza del numero da trovare, l'istruzione:

break PRIMA_LABEL;

fa terminare anche il ciclo esterno, e il programma continua stampando il messaggio Ricerca terminata, e poi termina.

Soluzione

Il listato potrebbe essere il seguente:

public class Esercizio4S {

    private static int matrice[][] = {
        {1, 7, 3, 9, 5, 3},
        {6, 2, 3},
        {7, 5, 1, 4, 0},
        {1, 0, 2, 9, 6, 3, 7, 8, 4}
    };

    public static void main(String args[]) {
        int numeroDaTrovare = controllaArgomento(args);
        if (numeroDaTrovare == -1) {
            System.out.println("Specificare un numero intero compreso tra"
              + " 0 e 9");
            return;
        }
        PRIMA_LABEL:
        for (int i = 0; i < matrice.length; i++) {
            int[] riga = matrice[i];
            for (int j = 0; j < riga.length; j++) {
                if (riga[j] == numeroDaTrovare) {
                    System.out.println(numeroDaTrovare + " trovato a riga = "
                      + ++i + ", colonna = " + ++j);
                    break PRIMA_LABEL;
                }
            }
        }
        System.out.println("Ricerca terminata");
    }

    private static int controllaArgomento(String[] args) {
        if (args.length == 1) {
            if (args[0].length() == 1) {
                for (int i = 0; i < 10; i++) {
                    if (args[0].equals("" + i)) {
                        return Integer.parseInt(args[0]);
                    }
                }
            }
        }
        return -1;
    }
}

Si noti che abbiamo delegato al metodo controllaArgomento la correttezza dell'input specificato dall'utente. Tale metodo ritorna il valore specificato, oppure, nel caso non sia corretto, il valore -1. Come è possibile vedere dal codice del metodo main, nel caso il valore ritornato dal metodo controllaArgomento sia -1, viene stampato un messaggio di istruzioni per l'utente, e con l'istruzione return, si esce dal metodo. Si noti che il metodo main ritorna void, quindi per uscire dal metodo si usa l'istruzione return senza specificare cosa ritornare.
Analizziamo ora il metodo controllaArgomento. Con il primo if abbiamo dapprima controllato che la lunghezza dell'array args sia 1, ovvero che sia stato specificato un unico argomento, utilizzando la variabile length dell'array (cfr. paragrafo 3.6.5). Con il secondo if abbiamo controllato che la lunghezza della stringa args[0] sia esattamente 1. Abbiamo sfruttato la chiamata al metodo length della classe String (da non confondersi con la variabile length dell'array). Il ciclo for seguente esegue un ciclo su valori che vanno da 0 a 9, e controlla che args[0] coincida con uno dei valori. Nel momento in cui trova una corrispondenza, il valore corrente viene ritornato dopo averlo convertito a intero mediante la chiamata al metodo statico della classe Integer parseInt (cfr. esercizio 3.t). Se invece nel ciclo for non si trovano corrispondenze, per esempio perché è stata specificata una lettera o un simbolo (quindi non un intero compreso tra 0 e 9), allora il ciclo terminerà e sarà ritornato il valore -1.

Soluzione

La classe CalcolatriceSemplificata richiesta potrebbe essere simile alla seguente:

public class CalcolatriceSemplificata {

    public double somma(double d1, double d2) {
        return d1 + d2;
    }

    public double sottrai(double d1, double d2) {
        return d1 - d2;
    }

    public double moltiplica(double d1, double d2) {
        return d1 * d2;
    }

    public double dividi(double d1, double d2) {
        return d1 / d2;
    }

    public double restituisciResto(double d1, double d2) {
        return d1 % d2;
    }

    public double massimo(double d1, double d2) {
        return d1 > d2 ? d1 : d2;
    }

    public double minimo(double d1, double d2) {
        return d1 > d2 ? d2 : d1;
    }

    public double media(double d1, double d2) {
        return (d1 + d2)/2;
    }
}

Mentre la classe per il suo test potrebbe essere:

public class Esercizio4T {

    public static void main(String args[]) {
        CalcolatriceSemplificata calcolatriceSemplificata = new CalcolatriceSemplificata();
        System.out.println("42.7 + 47.8 = " + calcolatriceSemplificata.somma(42.7, 47.8));
        System.out.println("42.7 - 47.8 = " + calcolatriceSemplificata.sottrai(42.7, 47.8));
        System.out.println("42.7 x 47.8 = " + calcolatriceSemplificata.moltiplica(42.7, 47.8));
        System.out.println("42.7 : 47.8 = " + calcolatriceSemplificata.dividi(42.7, 47.8));
        System.out.println("il resto della divisione tra 42.7 e 47.8 è " + calcolatriceSemplificata.restituisciResto(42.7, 47.8));
        System.out.println("Il massimo tra 42.7 e 47.8 è " + calcolatriceSemplificata.massimo(42.7, 47.8));
        System.out.println("Il minimo tra 42.7 e 47.8 è " + calcolatriceSemplificata.minimo(42.7, 47.8));
        System.out.println("La media tra 42.7 e 47.8 è " + calcolatriceSemplificata.media(42.7, 47.8));
    }
}

Soluzione

Il listato richiesto potrebbe essere il seguente:

import java.util.*;

public class Esercizio4U {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Digita il primo operando e batti enter.");
        double primoOperando = Double.parseDouble(scanner.nextLine());
        System.out.println(
          "Ora scegli l'operazione da eseguire e batti enter:");
        stampaTabellaOperazioni();
        String operazione = scanner.nextLine();
        System.out.println("Ora scegli il secondo operando e batti enter ");
        double secondoOperando = Double.parseDouble(scanner.nextLine());
        double risultato =
          eseguiOperazione(primoOperando, secondoOperando, operazione);
        System.out.println("Risultato = " + risultato);
    }

    private static double eseguiOperazione(double primoOperando,
      double secondoOperando, String operazione) {
        CalcolatriceSemplificata calcolatriceSemplificata =
          new CalcolatriceSemplificata();
        switch (operazione) {
            case "+":
                return calcolatriceSemplificata.somma(
                            primoOperando, secondoOperando);
            case "-":
                return calcolatriceSemplificata.sottrai(
                            primoOperando, secondoOperando);
            case "x":
                return calcolatriceSemplificata.moltiplica(
                            primoOperando, secondoOperando);
            case "d":
                return calcolatriceSemplificata.dividi(
                            primoOperando, secondoOperando);
            case "r":
                return calcolatriceSemplificata.restituisciResto(
                            primoOperando, secondoOperando);
            case "u":
                return calcolatriceSemplificata.massimo(
                            primoOperando, secondoOperando);
            case "m":
                return calcolatriceSemplificata.minimo(
                            primoOperando, secondoOperando);
            default:
                System.out.println("Operazione specificata " + operazione +
                                   " non valida");
                System.exit(1);
                return Double.NaN;
        }
    }

    private static void stampaTabellaOperazioni() {
        System.out.println("'+' : somma");
        System.out.println("'-' : sottrai");
        System.out.println("'x' : moltiplica");
        System.out.println("'d' : dividi");
        System.out.println("'r' : restituisci resto della divisione");
        System.out.println("'u' : massimo");
        System.out.println("'m' : minimo");
    }
}

La traccia dell'esercizio aveva già delineato come implementare l'interazione tra l'utente e il programma. Per il resto il codice è abbastanza chiaro, e faremo giusto delle osservazioni sui punti più oscuri.
Si noti che per eseguire i calcoli abbiamo usato il tipo di dato numerico più largo: il double. Si noti anche l'utilizzo del metodo statico parseDouble della classe Double, che converte una stringa in double (cfr. documentazione ufficiale), così come il metodo parseInt della classe Integer converte una stringa in int (cfr. esercizio 3.t).

Digita il primo operando e batti enter.
2.3
Ora scegli l'operazione da eseguire e batti enter:
'+' : somma
'-' : sottrai
'x' : moltiplica
'd' : dividi
'r' : restituisci resto della divisione
'u' : massimo
'm' : minimo
Ora scegli il secondo operando e batti enter 
2
Risultato = 0.2999999999999998

Questo è dovuto dal modo in cui viene rappresentato il tipo double in memoria, e lo avevamo anche accennato nel paragrafo 3.3.2.1 (bisognerebbe utilizzare il tipo BigDecimal, cfr. documentazione ufficiale), ed è un problema comune a tutti i linguaggi di programmazione moderni che utilizzano lo stesso metodo di rappresentazione in memoria (Standard IEEE-754). Il metodo System.exit fa terminare il programma istantaneamente. C'è da notare inoltre che il programma propone all'utente di scegliere delle lettere specifiche (vedi metodo eseguiOperazione) per eseguire la scelta dell'operazione da eseguire.

Soluzione

La classe StranaCalcolatrice potrebbe essere la seguente:

public class StranaCalcolatrice {

    public double somma(double[] doubles) {
        double risultato = 0;
        for (double unDouble : doubles) {
            risultato += unDouble;
        }
        return risultato;
    }

    public double moltiplica(double[] doubles) {
        double risultato = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
           risultato *= doubles[i];
        }
        return risultato;
    }

    public double massimo(double[] doubles) {
        double max = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
            double unDouble = doubles[i];
            if (unDouble > max) {
                max = unDouble;
            }
        }
        return max;
    }

    public double minimo(double[] doubles) {
        double min = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
            double unDouble = doubles[i];
            if (unDouble < min) {
                min = unDouble;
            }
        }
        return min;
    }
}

Il metodo somma è molto semplice e viene usato un semplice ciclo foreach per eseguire la somma. Negli altri tre casi, abbiamo dovuto prima recuperare il primo elemento, per poi svolgere le operazioni con il resto degli elementi dell'array passato in input.
Mentre la classe di test potrebbe essere la seguente:

public class Esercizio4V {

    public static void main(String args[]) {
        StranaCalcolatrice stranaCalcolatrice = new StranaCalcolatrice();
        double [] a1 = {42.7, 47.8};
        System.out.println("42.7 + 47.8 = " + stranaCalcolatrice.somma(a1));
        double [] a2 = {42.7, 47.8, 2};
        System.out.println("42.7 x 47.8 x 2= " +
            stranaCalcolatrice.moltiplica(a2));
        double [] a3 = {42.7, 47.8, 50, 2, 8, 89};
        System.out.println("Il massimo tra 42.7, 47.8, 50, 2, 8, 89 è " +
            stranaCalcolatrice.massimo(a3));
        double [] a4 = {42.7, 47.8, 50, 2, 8, 89};
        System.out.println("Il minimo tra 42.7, 47.8, 50, 2, 8, 89 è " +
            stranaCalcolatrice.minimo(a4)); */
    }
}

public class StranaCalcolatrice {

    public double somma(double... doubles) {
        double risultato = 0;
        for (double unDouble : doubles) {
            risultato += unDouble;
        }
        return risultato;
    }

    public double moltiplica(double... doubles) {
        double risultato = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
           risultato *= doubles[i];
        }
        return risultato;
    }

    public double massimo(double... doubles) {
        double max = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
            double unDouble = doubles[i];
            if (unDouble > max) {
                max = unDouble;
            }
        }
        return max;
    }

    public double minimo(double... doubles) {
        double min = doubles[0];
        for (int i = 1; i < doubles.length; i++) {
            double unDouble = doubles[i];
            if (unDouble < min) {
                min = unDouble;
            }
        }
        return min;
    }
}

public class Esercizio4V {

    public static void main(String args[]) {
        StranaCalcolatrice stranaCalcolatrice = new StranaCalcolatrice();
        System.out.println("42.7 + 47.8 = " +
                      stranaCalcolatrice.somma(42.7, 47.8));
        System.out.println("42.7 x 47.8 x 2= " +
                      stranaCalcolatrice.moltiplica(42.7, 47.8, 2));
        System.out.println("Il massimo tra 42.7, 47.8, 50, 2, 8, 89 è " +
                      stranaCalcolatrice.massimo(42.7, 47.8, 50, 2, 8, 89));
        System.out.println("Il minimo tra 42.7, 47.8, 50, 2, 8, 89 è " +
                      stranaCalcolatrice.minimo(42.7, 47.8, 50, 2, 8, 89));
    }
}

Soluzione

Il listato richiesto potrebbe essere il seguente:

import java.util.*;

public class Esercizio4Z {

    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.println(
          "Digita un operando e batti enter, tutte le volte che vuoi." +
          "\nQuando hai finito scegli l'operazione da eseguire e batti enter.");
        stampaTabellaOperazioni();
        String temp;
        String operandiString = "";
        while (isNotOperation(temp = scanner.nextLine())) {
            operandiString += temp + "-";
        }
        if (isNotOperation(temp)) {
            System.out.println("Errore codice operazione");
        }
        String[] operandiArray = operandiString.split("-");
        double[] operandi = new double[operandiArray.length];
        for (int i = 0; i < operandiArray.length; i++) {
            operandi[i] = Double.parseDouble(operandiArray[i]);
        }
        double risultato = eseguiOperazione(operandi, temp);
        System.out.println("Risultato = " + risultato);
    }

    private static boolean isNotOperation(String line) {
        if (line.equals("+") || line.equals("x") || line.equals("u") ||
          line.equals("m")) {
            return false;
        }
        return true;
    }

    private static double eseguiOperazione(double[] operandi,
      String operazione) {
        StranaCalcolatrice stranaCalcolatrice = new StranaCalcolatrice();
        switch (operazione) {
            case "+":
                return stranaCalcolatrice.somma(operandi);
            case "x":
                return stranaCalcolatrice.moltiplica(operandi);
            case "u":
                return stranaCalcolatrice.massimo(operandi);
            case "m":
                return stranaCalcolatrice.minimo(operandi);
            default:
                System.out.println("Operazione specificata " + operazione
                  + " non valida");
                System.exit(1);
                return Double.NaN;
        }
    }

    private static void stampaTabellaOperazioni() {
        System.out.println("'+' : somma");
        System.out.println("'x' : moltiplica");
        System.out.println("'u' : massimo");
        System.out.println("'m' : minimo");
    }
}

Abbiamo deciso di far specificare all'utente tutti gli operandi, per poi eseguire l'operazione nel momento in cui viene specificato un possibile operatore. Progettare una soluzione al problema non era affatto banale. Anche in questo caso non abbiamo gestito (non era richiesto) l'eventuale scorretto utilizzo del programma da parte dell'utente, perché troppo impegnativo per le nozioni che abbiamo studiato sin qui. Con la gestione delle eccezioni che studieremo nel capitolo 8 invece si troveranno delle soluzioni semplici. Il punto critico del codice riguarda la gestione dell'input, che deve essere analizzato e trasformato in tipi di dati che servono per compiere le nostre operazioni (double). Purtroppo ci manca un argomento molto importante che non abbiamo ancora studiato come le collection (che approfondiremo solo nell'appendice H, ma introdurremo a partire dal capitolo 10). Senza questo argomento, per immagazzinare i vari operandi specificati dall'utente, ci siamo dovuti arrangiare con una stringa (operandiString) che conteneva i vari operandi separati dal simbolo di trattino. Poi con il metodo split (vedi documentazione della classe String), abbiamo ottenuto un array di operandi sotto forma di stringa (operandiArray). Poi abbiamo istanziato un array di double operandi della stessa dimensione di operandiArray, e lo abbiamo riempito con gli operandi di tipo double dopo averli convertiti tramite il metodo statico parseDouble della classe Double.
Una soluzione piuttosto artificiosa, che però ha funzionato. Ecco un esempio di esecuzione dell'applicazione:

Digita un operando e batti enter, tutte le volte che vuoi.
Quando hai finito scegli l'operazione da eseguire e batti enter.
'+' : somma
'x' : moltiplica
'u' : massimo
'm' : minimo
2
3
4
5
6
7.28
x
Risultato = 5241.6

Soluzione

Il codice richiesto potrebbe essere il seguente:

import java.util.*;

public class GiocoTestaOCroce {
    public static void main(String args[]) {
        System.out.println("Cosa scegli testa o croce?");
        Scanner scanner = new Scanner(System.in);
        String scelta = scanner.nextLine();
        if ("testa".equals(scelta)) {
            System.out.println("Ok, lancio...");
            TestaOCroce testaOCroce = new TestaOCroce();
            String risultatoLancio = testaOCroce.dammiTestaOCroce();
            System.out.print("È uscito " +  risultatoLancio + "...");
            System.out.println("testa".equalsIgnoreCase(risultatoLancio) ?
                "hai vinto!" : "hai perso!");
        } else if ("croce".equals(scelta)) {
            System.out.println("Ok, lancio...");
            TestaOCroce testaOCroce = new TestaOCroce();
            String risultatoLancio = testaOCroce.dammiTestaOCroce();
            System.out.print("È uscito " +  risultatoLancio + "...");
            System.out.println("croce".equalsIgnoreCase(risultatoLancio) ?
                "hai vinto!" : "hai perso!");
        } else {
            System.out.println(
                "Mi dispiace, puoi scrivere solo testa o croce, riprova...");
            System.out.println("Programmata terminato... ciao!");
        }
    }
}

Soluzione

Il codice richiesto potrebbe essere il seguente:

import java.util.*;

public class GiocoTestaOCroce {
    public static void main(String args[]) {
        System.out.println(
            "Giochiamo a testa o croce, quante lanci vuoi fare?");
        Scanner scanner = new Scanner(System.in);
        String numeroLanciString = scanner.nextLine();
        int numeroLanci = Integer.parseInt(numeroLanciString);
        int contatoreLanci = 1;
        var numeroVittorie = 0;
        var numeroSconfitte = 0;
        String messaggio = "";
        System.out.println("Hai scelto di fare "+ numeroLanci +"...iniziamo!");
        while (contatoreLanci <= numeroLanci) {
            System.out.println("Lancio numero " + contatoreLanci);
            System.out.println("Cosa scegli testa o croce?");
            String scelta = scanner.nextLine();
            if ("testa".equals(scelta)) {
                System.out.println("Ok, lancio...");
                TestaOCroce testaOCroce = new TestaOCroce();
                String risultatoLancio = testaOCroce.dammiTestaOCroce();
                contatoreLanci++;
                System.out.print("È uscito "+ risultatoLancio + "...");
                if ("testa".equalsIgnoreCase(risultatoLancio)) {
                        messaggio = "hai vinto!";
                        numeroVittorie++;
                } else {
                        messaggio = "hai perso!";
                        numeroSconfitte++;
                }
            } else if ("croce".equals(scelta)) {
                System.out.println("Ok, lancio...");
                TestaOCroce testaOCroce = new TestaOCroce();
                String risultatoLancio = testaOCroce.dammiTestaOCroce();
                contatoreLanci++;
                System.out.print("È uscito "+ risultatoLancio + "...");
                 if ("croce".equalsIgnoreCase(risultatoLancio)) {
                        messaggio = "hai vinto!";
                        numeroVittorie++;
                } else {
                        messaggio = "hai perso!";
                        numeroSconfitte++;
                }
            } else {
                messaggio = "Mi dispiace, puoi scrivere solo testa o croce,"
                    + " riprova...";
            }
            System.out.println(messaggio);
        }
        messaggio = "Hai vinto " + numeroVittorie + " volte, e perso " +
            numeroSconfitte + " volte, quindi...";
        if (numeroVittorie > numeroSconfitte) {
            messaggio += "hai vinto la partita! Complimenti!";
        } else if (numeroVittorie < numeroSconfitte) {
            messaggio += "hai perso la partita! Ah ah!";
        } else {
            messaggio += "hai pareggiato partita! Riprova!";
        }
        System.out.println(messaggio);
    }
}

Il codice è abbastanza comprensibile, ed il lettore dovrebbe essere in grado di interpretarlo da solo. Notiamo che abbiamo usato il metodo equalsIgnoreCase della classe String per fare i confronti senza tenere conto delle lettere maiuscole e minuscole. Inoltre possiamo notare la gestione della variabile contatoreLanci, che viene incrementato solo quando effettivamente il lancio viene eseguito, ma non quando il lancio non viene eseguito nel caso l'input dell'utente non sia compatibile con la logica del programma.

Soluzione

Inseriamo nella classe Rubrica il metodo richiesto:

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")
        };
    }

    public Contatto[] cercaContattiPerNome(String nome) {
        Contatto []contattiTrovati = new Contatto[contatti.length];
        for (int i = 0, j = 0;  i < contattiTrovati.length; i++) {
            if (contatti[i].nome.toUpperCase().contains(nome.toUpperCase())) {
                contattiTrovati[j] = contatti[i];
                j++;
            }
        }
        return contattiTrovati;
    }
}

L'algoritmo non è banale, ed usa anche un ciclo for che sfrutta due indici (i e j), che vengono usati per i due array coinvolti. Notare che l'array restituito (contattiTrovati) avrà la stessa dimensione dell'array contatti, anche se magari i suoi elementi non saranno inizializzati. Notare anche che prima di usare il metodo contains della classe String per controllare se un nome di un contatto contiene la parametro di metodo nome, abbiamo usato il metodo toUpperCase per fare un confronto che non dipende dalla maiuscole e dalle minuscole. La classe RicercaContatti richiesta, la potremmo implementare nel seguente modo:

import java.util.Scanner;

public class RicercaContatti {
    public static void main(String args[]) {
        System.out.println("Ricerca Contatti");
        System.out.println();
        var rubrica = new Rubrica();
        System.out.println("Inserisci nome o parte del nome da ricercare");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        Contatto[] contattiTrovati = rubrica.cercaContattiPerNome(input);
        System.out.println("Contatti trovati con nome contenente \"" +
            input +"\"" );
        for (Contatto contatto : contattiTrovati) {
            if (contatto != null) {
                contatto.stampaDettagli();
            }
        }
    }
}

Notare che vengono stampati gli elementi dell'array ritornato, solo se diversi da null.

Soluzione

1. Vero.
2. Falso.
3. Vero.
4. Vero.
5. Vero.
6. Vero, le variabili non inizializzate vengono inizializzate ai propri valori nulli. Una stringa, essendo un oggetto, ha come valore nullo proprio null.
7. Falso.
8. Falso.
9. Falso, è possibile dichiarare un metodo main, ma non avrà lo stesso ruolo di "metodo iniziale" come in un ordinario programma Java.
10. Vero.

Soluzione

1. Falso, bisogna digitare il comando exit.
2. Falso, tutti i comandi JShell devono avere come prefisso /.
3. Vero.
4. Falso, è vero che il comando history mostra tutti gli snippet e tutti i comandi lanciati dall'utente nella sessione corrente. Ma non è vero che accanto agli snippet è presente uno snippet id.
5. Falso, il comando list mostra tutti gli snippet digitati dall'utente in questa sessione, con accanto i rispettivi snippet id.
6. False, il comando /types -all elencherà tutte i tipi (classi, interfacce, enumerazioni, annotazioni) dichiarate nella sessione corrente. Piuttosto il comando /variables -all elencherà tutte le variabili dichiarate nella sessione corrente.
7. Vero.
8. Vero.
9. Falso, è vero che importeremo in questa sessione, tutte i package di Java Standard Edition, ma non nelle future sessioni (avremmo dovuto esplicitare anche l'opzione -retain).
10. Vero.

Soluzione

L'output del comando list sarà vuoto. Infatti il comando reset avrà resettati tutti gli snippet immessi.

Soluzione

L'output del comando history sarà il seguente:

public int a;
private String a
/reset
/list
/history

Soluzione

Il comando corretto è:

/open HelloWorld.java

Soluzione

Possiamo solo invocare il metodo main nel seguente modo:

jshell> HelloWorld hw = new HelloWorld();
hw ==> HelloWorld@52a86356

jshell> hw.main(null);
Hello World!

Notare che siccome l'array args non viene utilizzato all'interno del metodo main, allora abbiamo potuto passargli null.
Anche se non l'abbiamo ancora studiato seriamente, il modificatore static ci permette di evitare di istanziare l'oggetto hw, e lanciare direttamente il comando usando il nome della classe:

jshell> HelloWorld.main(null)
Hello World!

Soluzione

Il comando corretto è:

/save C:/cartella/HelloWorld.java

Soluzione

1. Vero, in questo caso si parla di variabile implicita, e JShell ne dedurrà automaticamente il tipo.
2. Vero, in questo caso si parla di forwarding reference, e JShell creerà il reference, ma non lo renderà disponibile sino a quando non dichiareremo anche il suo tipo. A quel punto il reference verrà sostituito e inizializzato a null.
3. Falso, bisogna invece premere contemporaneamente i tasti "SHIFT e TAB", rilasciarli e dopo premere il tasto "v" (che sta per "variable"). JShell dedurrà il tipo della variabile, la dichiarerà e posizionerà il cursore subito dopo per permetterci di definire il reference.
4. Falso, bisogna invece premere contemporaneamente i tasti "SHIFT e TAB", rilasciarli e dopo premere il tasto "i" (che sta per "input").
5. Falso, verrà aperto il programma JShell Edit Pad, a meno che prima non si sia impostato come editor di default Notepad++ mediante il comando:

/set editor C:\Program Files (x86)\Notepad++\notepad++.exe

Soluzione

Il codice richiesto potrebbe essere il seguente:

public class AlfabetoArray {
    public static void main(String args[]) {
        char alfabeto [] = new char[26];
        int i = 0;
        for (char c = 'a'; c <= 'z'; c++, i++) {
           alfabeto[i] = (char)c;
        }
        System.out.println(alfabeto);
    }
}

Soluzione

Meglio usare un ciclo for migliorato:

public class AlfabetoArray {
    public static void main(String args[]) {
        char alfabeto [] = new char[26];
        int i = 0;
        for (char c = 'a'; c <= 'z'; c++, i++) {
           alfabeto[i] = (char)c;
        }
        for (char lettera : alfabeto) {
            System.out.println(lettera);
        }
    }
}