/* ************************************************************************
 * Abbiamo visto come stampare a video, ora vedremo come far immettere da
 * tastiera dei valori.
 * Qua la situazione si complica, infatti dovremo leggere una stringa,
 * gestendo tra l'altro il caso in cui si verifichi un errore, poi
 * convertirla nel formato della nostra variabile (float).
 * Le stringhe in Java sono considerate come oggetti, non si tratta di
 * array di char con zero terminale. La dichiarazione di una stringa e'
 * simile a quella di un int o un float:
 *
 *   String miastringa;
 *
 * Per leggere una stringa da tastiera, occorre usare il metodo readLine()
 * di DataInputStream, che estende (e' derivata da) FilterInputStream, che
 * a sua volta estende java.io.InputStream.
 * Per accedere a DataInputStream.readLine() occorre istanziare un oggetto
 * di tipo DataInputStream. In java per istanziare un oggetto si usa
 * l'operatore new (nuovo), in questo modo:
 *
 *   DataInputStream leggilo = new DataInputStream(System.in);
 *
 * Al costruttore passiamo lo stream (flusso) da cui prendere input, che
 * nel nostro caso e' System.in.
 * Ora abbiamo un DataInputStream chiamato leggilo, che possiamo usare
 * per leggere una stringa:
 * 
 *   miastringa = leggilo.readLine();          // leggo stringa da tastiera
 *
 * Ora dobbiamo convertire "miastringa" in un valore float, e salvarla.
 *
 *   vara = Float.valueOf(stringa).floatValue();  // e la converto in float.
 *
 * Sono disponibili anche Integer.valueOf(), Double.valueOf(), eccetera.
 * Il .floatValue() finale indica che si consideri anche la parte decimale,
 * dopo la virgola (o, meglio, il punto). Se si fosse specificato:
 *
 *   vara = Float.valueOf(stringa).intValue();
 *
 * La stringa sarebbe convertita in float, ma senza la parte dopo la virgola,
 * ad esempio 23.43 sarebbe convertito come 23.
 * Come se non bastasse, occorre gestire l'eventualita' di un errore, che
 * genererebbe un'eccezione. Le eccezioni vengono generate in caso di
 * errore durante l'esecuzione, e servono per far eseguire delle istruzioni
 * di emergenza, come la stampa di messaggi di errore e l'interruzione del
 * programma.
 * Per gestire le eccezioni si usa la coppia di istruzioni try e catch.
 * Try significa "prova", e catch "afferrare,cogliere".
 * Occorre mettere l'istruzione che puo' generare eccezioni nel blocco di
 * try: "prova ad eseguire questa istruzione". Subito dopo, occorre mettere
 * il catch, e nel suo blocco le istruzioni da eseguire in caso di errore:
 * "Se e' avvenuta una eccezione, acchiappala e fai le x operazioni di
 * emergenza". Il tutto applicato al nostro input:
 *
 *   try {
 *     stringa = leggilo.readLine();              // leggo stringa da tastiera
 *     vara = Float.valueOf(stringa).floatValue();  // e la converto in float.
 *   }
 *   catch (Exception e) {
 *     System.out.println("Errore: " + e + " nella lettura da tastiera");
 *     System.exit(0);
 *   }
 *
 * Come si vede, si provano ad eseguire la lettura e la conversione da
 * tastiera, e in caso di errore di stampa un messaggio, contenente il
 * nome dell'eccezione (al catch e' passata l'eccezione, che ha il nome
 * "e", stampabilissimo), e si termina l'esecuzione con la funzione
 * System.exit().
 ************************************************************************ */


import java.io.*;         // Include le funzioni I/O standard di base.
import java.lang.Math.*   // Include le funzioni matematiche (per il PI)


class Jlez1e {            // Da qua inizia la classe Jlez1e

 public static void main(String args[])  // Definiamo il metodo Main.
 {                                       // Inizio del main()

    float vara = 0, varb = 0;            // Dichiaro 2 variabili float
    String stringa;                      // Dichiaro una stringa

    System.out.println("\nDammi il primo numero:");  // stampo il messaggio

// Si istanzia un oggetto DataInputStream il cui stream (flusso) e' il
// System.in (ossia l'input da tastiera) per usare il suo metodo readLine().

    DataInputStream leggilo = new DataInputStream(System.in);

// Lettura di un numero da tastiera e suo salvataggio in una variabile float
// In caso di errore si genera un'eccezione, che fa stampare un messaggio
// di errore, e si termina l'esecuzione.

    try {
      stringa = leggilo.readLine();              // leggo stringa da tastiera
      vara = Float.valueOf(stringa).floatValue();  // e la converto in float.
    }
    catch (Exception e) {
      System.out.println("Errore: " + e + " nella lettura da tastiera");
      System.exit(0);
    }

    System.out.println("\nDammi il secondo numero:");  // Stampo il messaggio

// Ripeto le operazioni try-catch per leggere un'altro float.

    try {
      stringa = leggilo.readLine();              // leggo stringa da tastiera
      varb = Float.valueOf(stringa).floatValue();  // e la converto in float.
    }
    catch (Exception e) {
      System.out.println("Errore: " + e + " nella lettura da tastiera");
      System.exit(0);
    }

    float varc = vara+varb;         // Assegno a varc il valore di vara+varb

// Ora stampiamo a video il valore delle 3 variabili

    System.out.println("\nSomma di " +vara+ " e " +varb+ " = " +varc);

 }               // Fine del metodo principale Main()

}            // Fine della classe Jlez1e


/* ************************************************************************
 * Se volete provare il funzionamento del try-catch, basta fare in modo
 * che un errore generi un'eccezione. Ad esempio, provate ad inserire
 * delle lettere anziche' un numero, o ad andare a capo senza scrivere
 * niente, e il programma si blocchera' stampando il tipo di eccezione:
 * java.lang.NumberFormatException, ossia errore di formato del numero.
 ************************************************************************ */