/* *************************************************************************
 * In alcuni casi potremmo avere la necessita' di passare subito dei
 * parametri al costruttore di una classe. E' possibile:
 *
 *     animale(int zamp) {    // Il costruttore. 1 parametro in entrata
 *       lunghezza = 0;
 *       numerozampe = zamp;
 *       System.out.println("animale inizializzato");
 *     }                                             // Fine costruttore
 *
 * In effetti, se si crea un dato animale, il numero di zampe lo possiamo
 * sapere subito... mentre la lunghezza puo' variare con l'eta', quindi
 * la metteremo dopo.
 * Il passaggio del valore al momento della dichiarazione si fa in un modo
 * abbastanza scontato:
 *
 *     animale cane = new animale(4);
 *
 ************************************************************************ */

import java.io.*;         // Include le funzioni I/O standard di base.


/* ********************************************************************** */

public class Jlez7d {            // Da qua inizia la classe Jlez7d

///////////////////////////////////////////////////////////////////////////
//                            Il main...
///////////////////////////////////////////////////////////////////////////

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

// Ora possiamo dichiarare alcuni oggetti di tipo animale. Durante la
// loro allocazione (tramite new) vengono eseguiti i metodi costruttori,
// a cui passiamo direttamente il num. delle zampe

    animale cane1 = new animale(4);       // ecco che dichiaro 3 animali
    animale cane2 = new animale(4);       // ossia creo degli esemplari dalla
    animale millepiedi = new animale(1000); // classe "astratta"

// Gli altri parametri li chiediamo all'utente.

    System.out.println("\nLunghezza cane 1?");
    cane1.mettilungh(leggiFloat());  // Passa a mettilungh il valore letto.

    System.out.println("Lunghezza cane 2?");
    cane2.mettilungh(leggiFloat());  // Passa a mettilungh il valore letto

    System.out.println("Lunghezza millepiedi?");
    millepiedi.mettilungh(leggiFloat());

    System.out.println("Num. esatto piedi del millepiedi?");
    millepiedi.mettizampe(leggiInt()); // Passa a mettizampe il val. letto.

// Ora visualiziamo lo stato degli animali, usando i loro metodi di lettura.

  System.out.print("\nStato del cane1: zampe = " + cane1.leggizampe());
  System.out.println(", lunghezza = " + cane1.leggilungh());

  System.out.print("\nStato del cane2: zampe = " + cane2.leggizampe());
  System.out.println(", lunghezza = " + cane2.leggilungh());

  System.out.print("\nStato del millepiedi: zampe = " + millepiedi.leggizampe());
  System.out.println(", lunghezza = " + millepiedi.leggilungh());

 }               // Fine del metodo principale Main()

/* -------------------------------------------------------------------------
 * Definiamo un metodo chiamato leggiInt(), che in entrata non ha
 * parametri, e in uscita restituisce un numero intero immesso da tastiera.
 *    int leggiInt()
 * ----------------------------------------------------------------------- */

 public static int leggiInt()
 {
    try {
      DataInputStream leggilo = new DataInputStream(System.in);
      String stringa = leggilo.readLine();     // dichiaro e leggo stringa.
      return(Integer.valueOf(stringa).intValue());  // e la converto in int.
    }
    catch (Exception e) {
      System.out.println("Errore: " + e + " nella lettura da tastiera");
      System.exit(0);
      return(-1);        // Questo return serve solo perche' il metodo
                         // abbia un int di ritorno anche in caso di errore
    }
 }               // Fine di "int leggiInt()"


/* -------------------------------------------------------------------------
 * Definiamo un metodo chiamato leggiFloat(), che in entrata non ha
 * parametri, e in uscita restituisce un numero float immesso da tastiera.
 *    float leggiFloat()
 * ----------------------------------------------------------------------- */

 public static float leggiFloat()
 {
    try {
      DataInputStream leggilo = new DataInputStream(System.in);
      String stringa = leggilo.readLine();     // dichiaro e leggo stringa.
      return(Float.valueOf(stringa).floatValue()); // e la converto in float.
    }
    catch (Exception e) {
      System.out.println("Errore: " + e + " nella lettura da tastiera");
      System.exit(0);
      return(-1);        // Questo return serve solo perche' il metodo
                         // abbia un int di ritorno anche in caso di errore
    }
 }               // Fine di "float leggiFloat()"

}            // Fine della classe Jlez7d

/* *************************************************************************
 * Definiamo la classe animale. Generera' il file animale.class.
 * Il compilatore dara' un warning (attenzione) perche' sarebbe preferibile
 * separare il listato della classe e compilarlo a parte in un file
 * chiamato animale.java. Comunque la compilazione avviene lo stesso.
 ************************************************************************ */

class animale {         // Definisco la classe animale

    private float lunghezza=0;    // Variabile privata
    private int numerozampe=0;    // Variabile privata

    animale(int zamp) {    // Il costruttore. 1 parametro in entrata
      lunghezza = 0;
      numerozampe = zamp;
      System.out.println("animale inizializzato con " + zamp + " zampe");
    }                                             // Fine costruttore

// Ora scriviamo i metodi pubblici della classe animale:

/*-------------------------------------------------------------------------*
 * mettilungh: definisce la lunghezza dell'animale.
 *             parametri: in entrata la lunghezza in formato float.
 *-------------------------------------------------------------------------*/

 public void mettilungh(float i)
 {
    lunghezza = i;   // Scrive il valore nella variabile privata "lunghezza".
 }

/*-------------------------------------------------------------------------*
 * mettizampe: definisce il numero di zampe dell'animale.
 *             parametri: in entrata il num. di zampe in formato int.
 *-------------------------------------------------------------------------*/

 public void mettizampe(int l)
 {
    numerozampe = l; // Scrive il valore nella variabile privata "numerozampe".
 }

/*-------------------------------------------------------------------------*
 * leggilungh: legge e restituisce la lunghezza dell'animale.
 *             parametri: in uscita la lunghezza in formato float.
 *-------------------------------------------------------------------------*/

 public float leggilungh()
 {
    return lunghezza;
 }

/*-------------------------------------------------------------------------*
 * leggizampe: legge e restituisce il num. di zampe dell'animale.
 *             parametri: in uscita il num. di zampe in formato int.
 *-------------------------------------------------------------------------*/

 public int leggizampe()
 {
    return numerozampe;
 }

}            // Fine della classe animale