/* *************************************************************************
 * Oltre ai metodi, possiamo sovrapporre (overload) anche i costruttori.
 * Supponiamo di voler rendere facoltativi i parametri del costruttore della
 * classe animale: si puo' non passargli niente, oppure il num. delle zampe,
 * oppure sia n. zampe che lunghezza.
 *
 * animale cane = new cane();
 * animale cane = new cane(4);	    // Definisco subito che ha 4 zampe
 * animale cane = new cane(4,40.5)  // Definisco subito 4 zampe e lungh. 40.5
 *
 * Questo rende piu' flessibile l'inizializzazione del nostro oggetto.
 ************************************************************************ */

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


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

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

///////////////////////////////////////////////////////////////////////////
//                            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,

    animale cane1 = new animale();            // Nessun parametro
    animale cane2 = new animale(4);           // 1 parametro
    animale millepiedi = new animale(1000,3); // 2 parametri

// 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("Num. zampe cane 1?");
    cane1.mettizampe(leggiInt());   // Passa a mettizampe il val. letto.

    System.out.println("Lunghezza cane 2?");
    cane2.mettilungh(leggiFloat());  // Passa a mettilungh il valore 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 Jlez8b

/* *************************************************************************
 * 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() {            // Il costruttore. Nessun parametro in entrata
      lunghezza = 0;
      numerozampe = 0;
    }                                             // Fine costruttore

    animale(int zamp) {    // Il costruttore. 1 parametro in entrata
      lunghezza = 0;
      numerozampe = zamp;
    }                                             // Fine costruttore

    animale(int zamp, float lung) {       // Il costruttore. 2 parametri
      lunghezza = lung;
      numerozampe = zamp;
    }                                             // 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