31° Applicazione: MaximumTest

public class MaximumTest {
   
    // determina max fra tre oggetti comparable
    public static <T extends Comparable<T>> T maximum(T x, T y, T z)
    {
        T max = x;    // per ipotesi
       
        if(y.compareTo(max) > 0)
            max = y;
       
        if(z.compareTo(max) > 0)
            max = z;   
       
        return max;
    }

    public static void main(String[] args) {
       
        System.out.printf("Il massimo fra %d, %d e %d risulta %d\n\n", 3,4,5, maximum(3, 4, 5));
    }
}

30° Applicazione: Metodo Generico.

public class MetodoGenerico {

    // definisco un metodo statico generico
    public static <E> void printArray(E[] inputArray) {
        for (E element : inputArray) {
            System.out.printf("%s ", element);
            // riga a capo
            System.out.println();
        }
    }

    public static void main(String[] args) {

        // array di Inteeger, Double, Character
        Integer[] integerArray = { 1, 2, 3, 4, 5, 6, 7 };
        Double[] doubleArray = { 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7 };
        Character[] characterArray = { 'H', 'E', 'L', 'L', 'O' };
       
        printArray(integerArray);
        printArray(doubleArray);
        printArray(characterArray);

    }
}

29° Applicazione: Esempio sui metodi sovraccaricati.

public class MetodiSovraccaricati {

    // metodo printArray stampa un array di Integer
    public void printArray(Integer[] inputArray) {

        // stampa elementi di array
        // tipo, elementoCorrente, array su cui ciclare col for
        for (Integer element : inputArray) {
            System.out.printf("%s ", element);
            // riga a capo
            System.out.println();
        }
    }// fine metodo printArray Integer

    // metodo printArray stampa un array di Double
    public void printArray(Double[] inputArray) {

        // stampa elementi di array Double
        // tipo, elementoCorrente, array su cui ciclare col for
        for (Double element : inputArray) {
            System.out.printf("%s ", element);
            // riga a capo
            System.out.println();
        }
    }// fine metodo printArray Double

    // metodo printArray stampa un array di Character
    public void printArray(Character[] inputArray) {

        // stampa elementi di array
        // tipo, elementoCorrente, array su cui ciclare col for
        for (Character element : inputArray) {
            System.out.printf("%s ", element);
            // riga a capo
            System.out.println();
        }
    }// fine metodo printArray Double

}

28° Applicazione: Esempio di ricorsione. Calcolo Fattoriale.

public class CalcolaFattoriale {

    // dichiarazione iterativa metodo fattoriale
    public long fattoriale(long numero){
        long risultato = 1;
       
        // esegue ciclo moltiplicazioni
        for(long i = numero; i >= 1; i--){
            risultato *= i;
        }
       
        return risultato;
    }// fine metodo fattoriale
   
    // visualizza i fattoriali dei valori 0-10
    public void visualizzaFattoriali(){
       
        // calcola i fattoriali da 0 a 10
        for (int cont = 0; cont <=10; cont++) {
            System.out.printf("%d! = %d\n", cont, fattoriale(cont));
        }
    }// finemetodo visualizzazione fattoriali
}// fine classe fattoriale

27° Applicazione: Diagramma UML gerarchia interfaccia Pagabile

 /*************************************************************/
 public interface Pagabile {

    double getPagamentoDovuto();    // calcola il pagamento
}

/*************************************************************/
public class Fattura implements Pagabile{

    private String numeroPezzo;
    private String descrizionePezzo;
    private int quantita;
    private double prezzoSingolo;   
   
   
   
    public Fattura(String numeroPezzo, String descrizionePezzo, int quantita,
            double prezzoSingolo) {
        this.numeroPezzo = numeroPezzo;
        this.descrizionePezzo = descrizionePezzo;
        this.quantita = quantita;
        this.prezzoSingolo = prezzoSingolo;
    }


    public String getNumeroPezzo() {
        return numeroPezzo;
    }


    public void setNumeroPezzo(String numeroPezzo) {
        this.numeroPezzo = numeroPezzo;
    }


    public String getDescrizionePezzo() {
        return descrizionePezzo;
    }


    public void setDescrizionePezzo(String descrizionePezzo) {
        this.descrizionePezzo = descrizionePezzo;
    }


    public int getQuantita() {
        return quantita;
    }


    public void setQuantita(int numero) {
        this.quantita = (numero < 0) ? 0 : numero;    // numero non negativo
    }


    public double getPrezzoSingolo() {
        return prezzoSingolo;
    }


    public void setPrezzoSingolo(double price) {
        this.prezzoSingolo = (price  < 0 ) ? 0.0 : price;
    }

    public String toString() {
        return String.format("%s: \n%s: %s (%s) \n%s: %d \n%s: $%,.2f",
                "fattura ",
                "numero del pezzo ", getNumeroPezzo(), getDescrizionePezzo(),
                "quantita' ", getQuantita(),
                "prezzo per singolopezzo ", getPrezzoSingolo());
    }

    @Override
    public double getPagamentoDovuto() {
        return getQuantita() * getPrezzoSingolo();
    }
}

/**************************************************
 * Non implementiamo i metodi astratti
 * quindi ridefiniamo la classeImpiegato come astratta
 * @author roberto
 *
 */
public abstract class Impiegato implements Pagabile{

    // attributi private
    private String nome;
    private String cognome;
    private String codiceFiscale;

    // costruttore con 3 argomenti: public
    public Impiegato(String _nome, String _cognome, String _cf) {
        super();
        this.nome = _nome;
        this.cognome = _cognome;
        this.codiceFiscale = _cf;
    }

    // Metodi public
    // Get| Set
    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCognome() {
        return cognome;
    }

    public void setCognome(String cognome) {
        this.cognome = cognome;
    }

    public String getCodiceFiscale() {
        return codiceFiscale;
    }

    public void setCodiceFiscale(String codiceFiscale) {
        this.codiceFiscale = codiceFiscale;
    }

    public String toString() {
        return String.format("%s %s\ncodice fiscale: %s",
                getNome(),
                getCognome(),
                getCodiceFiscale());
    }
   
    /**
     * Non implementiamo il metodo
     * getPagamentoDovuto
     * quindi la classe la definiamo abstract
     */
}

/*************************************************************/
 public class ImpiegatoSalariato extends Impiegato {

    // attributi
    private double pagaSettimanale;

    // eredita costruttore da Impiegato
    public ImpiegatoSalariato(String _nome, String _cognome,
            String _codiceFiscale, double _pagaSettimanale) {

        super(_nome, _cognome, _codiceFiscale);

        // inizializzo pagaSettimanale
        setPagaSettimanale(_pagaSettimanale);
    }

    /**
     * Get | Set
     */
    public double getPagaSettimanale() {
        return pagaSettimanale;
    }

    public void setPagaSettimanale(double _paga) {
        this.pagaSettimanale = _paga < 0.0 ? 0.0 : _paga;
    }

   
    public String toString() {
        return String.format("Impiegato salariato: %s\n%s: $%,.2f",
                super.toString(), "Paga settimanale", getPagaSettimanale());
    }

    @Override
    public double getPagamentoDovuto() {
        return getPagaSettimanale();
    }
}

/********************************************************/
public class TestPagabile {

    public static void main(String[] args) {
   
        // definiamo array di 4 elementi
        Pagabile oggettiPagabili[] = new Pagabile[4];
       
        // popoliamo array
        oggettiPagabili[0] = new Fattura("01234", "sedile", 2, 375.00);
        oggettiPagabili[1] = new Fattura("56789", "gomma",  4, 79.95);
        oggettiPagabili[2] = new ImpiegatoSalariato("Sara", "Rossi", "SRA RSS 01 A41 A123B", 800.00);
        oggettiPagabili[3] = new ImpiegatoSalariato("Roberto", "Bianchi", "RBT BNC 71 F15 B321 H", 1200.00);

        System.out.println("Fatture ed impiegati elaborati in modo polimorfica:\n");
        for (Pagabile pagabile : oggettiPagabili) {
            // visualizza pagabile
            System.out.printf("%s \n%s: $%,.2f\n\n", pagabile.toString(),
                    "pagamento dovuto", pagabile.getPagamentoDovuto());
        }
    }// fine main
}

26° Applicazione: Diagramma classi gerarchia Impiegato

Definizione di classe astratta:
 Una classe astratta è una classe che viene definita solo per stabilire una interfaccia
comune per tutte le sue sottoclassi.

    - Può avere uno o più metodi astratti   
    - Ogni sottoclasse dovrà definire tutti i metodi astratti,
      altrimenti dovrà essere etichettata anch'essa come astratta.
  
    - Oltre a metodi astratti
      una classe astratta può contenere dati e metodi non astratti.
  
    - Non può essere istanziata.
    - Può avere un costruttore che non sarà mai usato direttamente
      (perché non esisteranno mai istanze),
      ma sarà chiamato dai costruttori delle classi derivate.
  
    - Per estendere una classe abstract si usa l'operatore extends ed ogni classe può estendere 
       una sola classe astratta.


1° classe astratta: Impiegato
public abstract class Impiegato {

    // attributi private
    private String nome;
    private String cognome;
    private String codiceFiscale;

    // costruttore con 3 argomenti: public
    public Impiegato(String _nome, String _cognome, String _codiceFiscale) {
        super();
        this.nome = _nome;
        this.cognome = _cognome;
        this.codiceFiscale = _codiceFiscale;
    }

    // Metodi public
    // Get| Set
    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCognome() {
        return cognome;
    }

    public void setCognome(String cognome) {
        this.cognome = cognome;
    }

    public String getCodiceFiscale() {
        return codiceFiscale;
    }

    public void setCodiceFiscale(String codiceFiscale) {
        this.codiceFiscale = codiceFiscale;
    }

    public String toString() {
        return String.format("%s %s\ncodice fiscale: %s", getNome(),
                getCognome(), getCodiceFiscale());
    }

    // metodo abstract public -> che sarà implementato nelle sottoclassi
    public abstract double guadagno(); // senza implementazione
}

 2° classe astratta: ImpiegatoSalariato 

public class ImpiegatoSalariato extends Impiegato {

    // attributi
    private double pagaSettimanale;

    // eredita costruttore da Impiegato
    public ImpiegatoSalariato(String _nome, String _cognome,
            String _codiceFiscale, double _pagaSettimanale) {

        super(_nome, _cognome, _codiceFiscale);

        // inizializzo pagaSettimanale
        setPagaSettimanale(_pagaSettimanale);
    }

    /**
     * Get | Set
     */
    public double getPagaSettimanale() {
        return pagaSettimanale;
    }

    public void setPagaSettimanale(double _paga) {
        this.pagaSettimanale = _paga < 0.0 ? 0.0 : _paga;
    }

   
    // eredita metodo astratto
    @Override
    public double guadagno() {
        return getPagaSettimanale();
    }
   
    public String toString() {
        return String.format("Impiegato salariato: %s\n%s: $%,.2f",
                super.toString(), "Paga settimanale", getPagaSettimanale());
    }
}

3° classe astratta: ImpiegatoAOre

public class ImpiegatoAOre extends Impiegato {

    private double pagaOraria;
    private double oreLavorate;

    public ImpiegatoAOre(String _nome, String _cognome, String _codiceFiscale,
            double _pagaOraria, double _oreLavorate) {

        super(_nome, _cognome, _codiceFiscale);

        setPagaOraria(_pagaOraria);
        setOreLavorate(_oreLavorate);

    }// fine costruttore

    public double getPagaOraria() {
        return pagaOraria;
    }

    public void setPagaOraria(double pagaOraria) {
        this.pagaOraria = (pagaOraria < 0.0) ? 0.0 : pagaOraria;
    }

    public double getOreLavorate() {
        return oreLavorate;
    }

    public void setOreLavorate(double ore) {
        this.oreLavorate = ((ore >= 0) && (ore <= 168.0)) ? oreLavorate : 0.0;
    }

    @Override
    public double guadagno() {
        if (getOreLavorate() <= 40) // nessun straordinario
            return getPagaOraria() * getOreLavorate();
        else
            return 40 * getPagaOraria() + (getOreLavorate() - 40)
                    * getPagaOraria() * 1.5;
    }

    public String toString() {
        return String.format("Impiegato ad ore: %s\n%s: $%,.2f; %s: %,.2f",
                super.toString(), "Paga oraria", getPagaOraria(),
                "ore lavorate:", getOreLavorate());
    }
}
 4° classe astratta: ImpiegatoACommissione

public class ImpiegatoACommissione extends Impiegato{

    private double venditeLorde;
    private double PercentualeCommissione;
   
   
    public ImpiegatoACommissione(String _nome, String _cognome,
            String _codiceFiscale, double _vendite, double _commissione) {
       
        super(_nome, _cognome, _codiceFiscale);
       
        setVenditeLorde(_vendite);
        setPercentualeCommissione(_commissione);
    }


    public double getVenditeLorde() {
        return venditeLorde;
    }


    public void setVenditeLorde(double vendite) {
        this.venditeLorde = (vendite < 0.0) ? 0.0 : vendite;
    }


    public double getPercentualeCommissione() {
        return PercentualeCommissione;
    }


    public void setPercentualeCommissione(double commiss) {
        PercentualeCommissione = (commiss > 0.0 && commiss < 1.0) ? commiss : 0.0;
    }

    @Override
    public double guadagno() {
        // TODO Auto-generated method stub
        return getPercentualeCommissione() * getVenditeLorde();
    }
   
   
    public String toString() {
        return String.format("%s %s\n%s: $%,.2f; %s: %,.2f",
                "impiegato a commissione", super.toString(),
                "vendite lorde", getVenditeLorde(),
                "percentuale commissione", getPercentualeCommissione());
    }
}

 5° classe astratta: ImpiegatoACommissioneSalariato

public class ImpiegatoACommissioneSalariato extends ImpiegatoACommissione {
  
    private double pagaBase;     
  
    public ImpiegatoACommissioneSalariato(String _nome, String _cognome,
            String _codiceFiscale, double _vendite, double _commissione, double paga) {
       
        super(_nome, _cognome, _codiceFiscale, _vendite, _commissione);
        setPagaBase(paga);       
    }

    public double getPagaBase() {
        return pagaBase;
    }

    public void setPagaBase(double paga) {
        this.pagaBase = (paga < 0.0 ) ? 0.0 : paga;
    }    

    public double guadagno(){
        return getPagaBase() + super.guadagno();
    }    

    public String toString() {
        return String.format("%s %s; %s: $%,.2f",
                "salariato", super.toString(),
                "paga base", getPagaBase());
    }
}

25° Applicazione: Esercitazione su Ereditarietà

public class ImpiegatoACommissione3 {

    private String nome;
    private String cognome;
    private String codiceFiscale;
    private double venditeLorde;
    private double percentualeCommissione;

    public ImpiegatoACommissione3(String _nome, String _cognome, String cf,
            double vendite, double commissione) {
        super();
        this.nome = _nome;
        this.cognome = _cognome;
        this.codiceFiscale = cf;
        this.venditeLorde = vendite;
        this.percentualeCommissione = commissione;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCognome() {
        return cognome;
    }

    public void setCognome(String cognome) {
        this.cognome = cognome;
    }

    public String getCodiceFiscale() {
        return codiceFiscale;
    }

    public void setCodiceFiscale(String codiceFiscale) {
        this.codiceFiscale = codiceFiscale;
    }

    public double getVenditeLorde() {
        return venditeLorde;
    }

    public double getPercentualeCommissione() {
        return percentualeCommissione;
    }

    public void setVenditeLorde(double venditeLorde) {

        this.venditeLorde = (venditeLorde < 0.0) ? 0.0 : venditeLorde;
    }

    public void setPercentualeCommissione(double percComm) {

        this.percentualeCommissione = (percComm > 0.0 && percComm < 1.0) ? percComm
                : 0.0;
    }

    // calcola il guadagno
    public double guadagno() {
        return getPercentualeCommissione() * getVenditeLorde();
    }

    @Override
    public String toString() {

        return String.format("%s: %s %s\n%s: %s\n%s: %.2f\n%s: %.2f",
                "impiegato a commissione: ", nome, cognome, "codice fiscale: ",
                codiceFiscale, "vendite lorde: ", venditeLorde,
                "percentuale di commissione ", percentualeCommissione);
    }
}

public class ImpiegatoACommissioneSalariato4 extends ImpiegatoACommissione3 {

    // attributi della classe
    private double stipendioBase; // stipendio base settimanale



    public ImpiegatoACommissioneSalariato4(String _nome, String _cognome,
            String cf, double vendite, double commissione, double stipendio) {
        super(_nome, _cognome, cf, vendite, commissione);
    }

    public double getStipendioBase() {
        return stipendioBase;
    }

    public void setStipendioBase(double stipendio) {
        this.stipendioBase = (stipendio < 0.0) ? 0.0 : stipendio;
    }

    // calcola il guadagno
    public double guadagno() {
        return getStipendioBase() + super.guadagno();
    }

    public String toString() {
        return String.format("%s %s\n%s: %.2f", "salariato",
                super.toString(),
                "stipendio base: ", getStipendioBase());
    }
}

Definizioni: Polimorfismo

Il polimorfismo permette di scrivere programmi in grado di operare su oggetti che condividono la stessa superclasse come se fossero tutte istanze  di quella superclasse, semplificando di molto la programmazione.

24° Applicazione: Impiegato a commissione

/**
 * classe ImpiegatoACommissione
 * pagato in percentuale sulle vendite.
 * @author roberto
 *
 */
public class ImpiegatoACommissione extends Object {

    private String nome;
    private String cognome;
    private String codiceFiscale;
    private double venditeLorde;
    private double percentualeCommissione;

    public ImpiegatoACommissione(String nome, String cognome,
            String codiceFiscale, double venditeLorde,
            double percentualeCommissione) {
       
        this.nome = nome;
        this.cognome = cognome;
        this.codiceFiscale = codiceFiscale;
//        this.venditeLorde = venditeLorde;
        setVenditeLorde(venditeLorde);                            // valida ed immagazzina vendite
//        this.percentualeCommissione = percentualeCommissione;
        setPercentualeCommissione(percentualeCommissione);        // valida la percentuale
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCognome() {
        return cognome;
    }

    public void setCognome(String cognome) {
        this.cognome = cognome;
    }

    public String getCodiceFiscale() {
        return codiceFiscale;
    }

    public void setCodiceFiscale(String codiceFiscale) {
        this.codiceFiscale = codiceFiscale;
    }

    public double getVenditeLorde() {
        return venditeLorde;
    }

    public void setVenditeLorde(double venditeLorde) {
       
        this.venditeLorde = (venditeLorde < 0.0) ? 0.0 : venditeLorde;
    }

    public double getPercentualeCommissione() {
        return percentualeCommissione;
    }

    public void setPercentualeCommissione(double percComm) {
       
        this.percentualeCommissione = (percComm > 0.0 && percComm < 1.0) ? percComm : 0.0;
    }
   
    // calcola il guadagno
    public double guadagno()
    {
        return percentualeCommissione * venditeLorde;
    }

    @Override
    public String toString() {
       
//        return "ImpiegatoSalariato [nome=" + nome + ", cognome=" + cognome
//                + "\n, codiceFiscale=" + codiceFiscale + "\n, venditeLorde="
//                + venditeLorde + "\n, percentualeCommissione="
//                + percentualeCommissione + "]";
       
        return String.format("%s: %s %s\n%s: %s\n%s: %.2f\n%s: %.2f",
                "impiegato a commissione: ", nome, cognome,
                "codice fiscale: ", codiceFiscale,
                "vendite lorde: ", venditeLorde,
                "percentuale di commissione ", percentualeCommissione);
    }
}

23° Applicazione: Esercizio di Enumerazione.

public enum Libro {

    // costanti
    JHTP6("Programmazione java 6", "2005"),
    CHTP4("Programmazre in C", "2004"),
    IW3HTP3("Internet ed il Web", "2004");
   
    // variabili di istanza
    private final String titolo;        // titolo del libro
    private final String annoCopyright;    // anno di copyright
   
    // costruttore enum
    Libro(String titoloLibro, String anno){
        this.titolo = titoloLibro;
        this.annoCopyright = anno;
    }

    public String getTitolo() {
        return titolo;
    }

    public String getAnnoCopyright() {
        return annoCopyright;
    }   
}

22° Applicazione: Classi ed Oggetti: Esercizio - Impiegato

public class Data {
   
    private int mese;        // 1-12
    private int giorno;        // 1-31
    private int anno;        // qualsiasi
   
    // costruttore
    public Data(int _mese, int _giorno, int _anno){
        this.mese = _mese;
        this.giorno = _giorno;
        this.anno = _anno;
   
        System.out.printf("Costruttore oggetto Data per la data: %s\n", this);
    }// fine costruttore
   
    // metodo di supporto per confermare mese corretto
    private int controllaMese(int verificaMese){
        if(verificaMese > 0 && verificaMese <= 12)    // test sul mese
            return verificaMese;
        else{
            System.out.printf("Mese non valido (%d) impostato ad 1.", verificaMese);
            return 1;    // mantiene la Data in uno stato coerente
        }
    }// fine controllo del mese
   
    // verifichiamo il giorno
    private int controllaGiorno(int verificaGiorno){
        int ggMesi[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
       
        // verifico se il giorno risulta corretto in base al mese
        if(verificaGiorno > 0 && verificaGiorno <= ggMesi[mese])
            return verificaGiorno;
       
        // verifico anno bisestile
        if(mese == 2 && verificaGiorno == 29 && (anno % 400 == 0 || (anno % 4 == 0 && anno % 100 != 0)))
            return verificaGiorno;
       
        System.out.printf("giorno errato (%d) posto ad 1.", verificaGiorno);
        return 1;
    }// fine controllo giorno
   
   
    // restituisce una stringa nella forma mese/giorno/anno
    public String toString(){
        return String.format("%d/%d/%d", giorno, mese, anno);
    }
}
import java.util.Date;

public class Impiegato {

    // variabili
    private String nome;
    private String cognome;
    private Data dataNascita;
    private Data dataAssunzione;
   
    // costruttore
    public Impiegato(String _nome, String _cognome, Data _nascita,
            Data _assunzione) {
        this.nome = _nome;
        this.cognome = _cognome;
        this.dataNascita = _nascita;
        this.dataAssunzione = _assunzione;
    }
   
    // conversione impiegato in forma stringa
    public String toString(){
        return String.format("%s,%s Assunto: %s Compleanno: %s", cognome, nome, dataAssunzione, dataNascita);
    }
}// fine classe impiegato

21° Applicazione: Gestione voti di una classe.

public class RegistroVoti {

    private String nomeCorso; // nome del corso
    private int voti[]; // array di voti

    public RegistroVoti(String nome, int arrayVoti[]) {

        this.nomeCorso = nome; // inizializza nome corso
        this.voti = arrayVoti; // memorizza voti
    }

    // ------------------------------------------------ Get | Set
    public String getNomeCorso() {
        return nomeCorso;
    }

    public void setNomeCorso(String nomeCorso) {
        this.nomeCorso = nomeCorso;
    }

    public int[] getVoti() {
        return voti;
    }

    public void setVoti(int[] voti) {
        this.voti = voti;
    }

    // ------------------------------------------------ Msg di benvenuto
    public void mostraMsg() {

        System.out.printf("Benvenuto al registro di\n%s!\n\n", getNomeCorso());
    }// fine mostra messaggio

   // ------------------------------------ Elabora voti
    // effettua varie operazioni sui dati
    public void elaboraVoti() {
        // visualizza array voti
        visualizzaVoti();

        // calcola media
        System.out.printf("\nMedia della classe: %.2f\n", calcolaMedia());

        // trova minimo, trova max
        System.out.printf("Voto più basso: %d\nVoto più alto: %d\n\n",
                trovaMin(), trovaMax());

        // visualizza diagramma a barre
        mostraDiagrammaABarre();

    }// fine metodo elebora voti

    // ------------------------------------ Diagramma a barre
    private void mostraDiagrammaABarre() {
        System.out.println("Distribuzione voti: ");
        // salvo freuenza per ognuno dei dieci voti:
        int frequenza[] = new int[11];
       
        // per ogni voto, incrementa la frequenzacorrispondente
        for (int voto : voti) {
            ++frequenza[voto / 10];
        }
       
        // per ogni frequenza di voto, mostra una barra
        for(int cnt = 0; cnt < frequenza.length; cnt++){
            if(cnt == 10) System.out.printf("%5d: ",   100);
            else
                System.out.printf("%02d-%02d: ", cnt * 10, cnt * 10 + 9);
           
            // visualizza barra
            for (int aster = 0; aster < frequenza[cnt]; aster++) {
                System.out.print("*");
            }
           
            System.out.println();
        }// fine for esterno
    }// fine diagramma a barre

    // ------------------------------------ calcola voto massimo
    public int trovaMax() {
        int votoMassimo = voti[0]; // per ipotesi, il primo voto risulta il massimo

        // itero su array voti
        for (int voto : voti) {
            // se il voto letto é minore di votoMinimo
            if (voto > votoMassimo)
                votoMassimo = voto; // assegno a votoMassimo il nuovo voto
        }// fine for

        return votoMassimo;
    }

    // ------------------------------------ calcola voto minimo
    public int trovaMin() {
        int votoMinimo = voti[0]; // per ipotesi, il primo voto risulta il
                                    // minore

        // itero su array voti
        for (int voto : voti) {
            // se il voto letto é minore di votoMinimo
            if (voto < votoMinimo)
                votoMinimo = voto; // assegno a votoMinimo il nuovo voto
        }// fine for

        return votoMinimo;
    }

    // ------------------------------------ calcola media voti
    public double calcolaMedia() {
        int totale = 0;
        // somma voti studenti
        for (int voto : voti) {
            totale += voto;
        }
        return (double) totale / voti.length;
    }

    // ------------------------------------ visualizza voti
    private void visualizzaVoti() {
        System.out.println("I voti sono: ");
        for (int studente = 0; studente < voti.length; studente++) {
            System.out.printf("Studente %2d: %3d\n", studente + 1, voti[studente]);
        }
    }
   
}// fine classe

20°Applicazione: Passaggio array come argomenti.

public class PassaggioArrayComeArgomenti {

    public static void main(String[] args) {

        int array[] = { 1, 2, 3, 4, 5};

        System.out
                .println("Passaggio di un riferimento all'interno di un array:\n"
                        + "Valori array originale: ");

        // visualizzazione array originale
        System.out.println("Array originale: ");
        for (int valore : array) {
            System.out.printf("%d", valore);
        }

        // passaggio di un riferimento all'array
        modificaArray(array);

        // visualizzo elementi array modificato
        System.out.println("\n\nArray modificato moltiplicando * 2: ");
        for (int valore : array) {           
            System.out.printf("   %d", valore);
        }

        System.out.printf(
                "\n\nEffetto del passaggio di un elemento dell'array:\n"
                        + "array[3] prma di modificaElemento: %d\n", array[3]);

        modificaElemento(array[3]); // tenta di modificare array[3]
        System.out.printf("array[3] dopo modificaElemento: %d\n", array[3]);

    }// fine main

    // moltiplica ogni elemento di un array per 2
    public static void modificaArray(int array2[]) {
        for (int cnt = 0; cnt < array2.length; cnt++) {
            array2[cnt] *= 2;
        }
    }

    // moltiplica argomento per 2
    public static void modificaElemento(int elemento) {
        elemento *= 2;
        System.out.printf("Valore di elemento in modificaElemento: %d\n",
                elemento);
    }// fine metodo modificaElemento

}// fine classe

19° Applicazione: Somma di valori in array.

public class SommaArray {

    public static void main(String[] args) {
        int mioArray[] = {87, 76, 95, 1, 37, 90, 65, 80, 10, 13};
        int tot = 0;
       
        // somma dei valori
        for (int i = 0; i < mioArray.length; i++) {
            tot += mioArray[i];
        }
       
        System.out.printf("Totale elementi array: %d\n", tot);
    }// fine main
}//fine classe

18°Applicazione: Inizializzazione array.

public class InizializzazioneArray {

    public static void main(String[] args) {
       
        int array[];            // dichiarazione array
        array = new int[10];    // dieci elementi
        System.out.printf("%s%8s\n", "Indice", "Valore");    // colonne
       
        // visualizzazione elementi
        for (int i = 0; i < array.length; i++) {
            System.out.printf("%5d%8d\n", i,array[i]);
        }// fine for
    }// fine main
}//fine classe

Definizioni: Overloading dei metodi

Overloading di metodi

All'interno di una classe é possibile dichiarare più metodi con lo stesso nome, a condizione che abbiano tutti una lisrta diversa di parametri (in riferimentoal loro numero, tipoed ordine).
Questo viene detto overloading o sovraccaricamento dei metodi.
- Viene usato per creare diversi metodi con lo stesso nome che eseguono lo stesso compito o simili, masu diversitipi onumero di argomenti differenti.

Esempio:
// metodo quadrato con argomento int
public int quadrato(int valore){
 System.out.printf("\nInvocato quadrato con argomento int: %d\n", valore);
 return valore * valore;
}// fine metodo quadrato

// metodo quadrato con argomento double
public int quadrato(double valore){
 System.out.printf("\nInvocato quadrato con argomento double: %d\n", valore);
 return valore * valore;
}// fine metodo quadrato

17° Applicazione: Uso di Random - Genera 20 numeri vincenti per il lotto.

/**
 * Generare numeri casuali
 * @author roberto
 *
 */
public class Random {

    public static void main(String[] args) {
       
        java.util.Random numeriCasuali = new java.util.Random();
        int numeroGenerato;    // salva numero generato
       
        // itera per 10 volte
        for (int i = 1; i <= 20; i++) {
            // limite dinumeri da generare tra 1 e 7
            numeroGenerato = 1 + numeriCasuali.nextInt(90);
           
            System.out.printf("%d:", numeroGenerato);    // visualizza numero generato
           
            // ogni 5 numeri vai a capo
            if( i % 5 == 0) System.out.println();   
        }// fine for
    }// fine main
}// fine classe

16° Applicazione: Calcola valore max fra 3 numeri in virgola mobile.

import java.util.Scanner;

public class MaxDiTreValori {

    public void calcolaMax() {
        // acquisiamo 3 valori in virgola mobile e calcoliamo il maggiore
        Scanner input = new Scanner(System.in);

        // acquisizione numeri da utente
        int cntNumeri = 0;

       
            System.out.print("Dgt 1° numero in virgola mobile: ");
            double num1 = input.nextDouble();
            System.out.print("Dgt 2° numero in virgola mobile: ");
            double num2 = input.nextDouble();
            System.out.print("Dgt 3° numero in virgola mobile: ");
            double num3 = input.nextDouble();

       

        // calcolo il max
        double risultato = max(num1, num2, num3);

        // visualizzo numero max
        System.out.println("Il valore massimo risulta:" + risultato);

    }

    private double max(double num1, double num2, double num3) {

        double valMax = num1; // ipotesi di valore massimo

/*
:: 1° metodo ::
        if (num2 > valMax)
            valMax = num2;
        if (num3 > valMax)
            valMax = num3;

        return valMax;
*/
/* 2° metodo */
         return Math.max(num1, Math.max(num2, num3));
    }
}

15° Applicazione: Utilizzo di 'continue' in java.

public class Continue {

    public static void main(String[] args) {

        int cnt; // variabile di controllo

        for (cnt = 1; cnt <= 10; cnt++) {
            if (cnt == 7)
                continue; // salta il resto del codice

            System.out.printf("%d", cnt);
        }// fine for

        System.out.printf("\n\nUtilizzato continue per non stampare il numero 7");

    }

}

14° Applicazione: Utilizzo di 'break' in java.

/**
 * Termina conteggio con istruzione break non appena il contatore varrà 7.
 *
 * @author roberto
 *
 */
public class Break {

    public static void main(String[] args) {

        int cnt; // variabile di controllo

        for (cnt = 1; cnt <= 10; cnt++) {
            if (cnt == 7)
                break; // se contatore uguale a 7 termina il ciclo

            System.out.printf("%d", cnt);
        }// fine for

        System.out.printf("\nSei uscito, contatore risulta: %d\n", cnt);
    }
}

13° Applicazione: Calcolo di interessi su base annua.

import javax.swing.JOptionPane;

/**
 * Calcoliamo il tasso interesse annuo
 * su conto corrente in base alla cifra presente sul conto
 * e stampare cifra maturata in ciascun anno
 * per 10 anni successivi. 
 *
 * @author roberto
 *
 */
public class CalcolaInteressi {

    public static void main(String[] args) {
       
        // definizione variabili
        double ammonta;            // deposito presente alla fine di ciascun anno
        double capitale;        // capitale iniziale
        double tassoInteresse;    // tasso di interesse
       
        String valoreIniziale =  JOptionPane.showInputDialog("Digitare capitale iniziale: ");
        capitale = Double.valueOf(valoreIniziale);
       
        String valoreTassoInteresse =  JOptionPane.showInputDialog("Digitare tasso interesse iniziale: ");
        tassoInteresse = Double.valueOf(valoreTassoInteresse);
        tassoInteresse = (tassoInteresse/100);
       
        // intestazioni titolo
        System.out.printf("%s\t%20s\n", "Annno", "Denaro presente in deposito");
       
        // calcoliamo deposito a fine anno
        for(int anno = 1; anno <= 10; anno++){
            ammonta = capitale * Math.pow(1.0 + tassoInteresse, anno);
           
            // visualizziamo anno e cifra in deposito:
            System.out.printf("%4d%, 20.2f\n", anno, ammonta);
        }// fine for
    }// fine main
}// fine classe interessi

12° Applicazione: Postincremento e preincremento.

public class Incremento {

    public static void main(String[] args) {

        int a;

        // funzione incremento suffisso
        a = 7; // assegno 7 ad a
        System.out.println("Visualizzo valore di a: " + a);
        // stampo valore di 'a' eppoi postincremento
        System.out.println("Valore di a: " + a++);
        // stampa valore di 'a' incrementato
        System.out.println("Valore di a incrementato di 1: " + a);

        // salto una riga
        System.out.println();

        // funzione incremento prefisso
        a = 7; // assegno 7 ad a
        System.out.println("Visualizzo valore di a: " + a);
        // stampo valore di 'a' eppoi preincremento
        System.out.println("Valore di a: " + ++a);
        // stampa valore di 'a' preincrementato
        System.out.println("Valore di a preincrementato di 1: " + a);
    }
}

11° Applicazione: Contatore con sentinella.

import java.util.Scanner;

public class ArchivioVoti2 {

    // calcolo media voti della classe
    // usando ciclo controllato da contatore
    private String nomeCorso;

    // costruttore
    public ArchivioVoti2(String nome) {
        nomeCorso = nome;
    }

    // Get-Set
    public String getNomeCorso() {
        return nomeCorso;
    }

    public void setNomeCorso(String nomeCorso) {
        this.nomeCorso = nomeCorso;
    }

    // MSG di benvenuto
    public void stampaMessaggio() {
        System.out.printf("Benvennuto in Archivio Voti \n%s", getNomeCorso());
    }

    // calcolo media di dieci voti inseriti da utente
    public void calcolaMediaVoti() {

        // Scanner per acquisire i voti
        Scanner input = new Scanner(System.in);

        int tot; // somma totale dei voti
        int cntVoti; // contatore voti
        int voto; // voto acquisito
        double media; // media dei voti

        // inizializzazione
        tot = 0;
        cntVoti = 0;

        // fase acquisizione voti
        System.out.println("Dgt voto oppure -1 per finire: ");
        voto = input.nextInt();

        // elaborazione calcoli più valore sentinella
        while (voto != -1) {

            tot += voto;
            cntVoti += 1;

            // acquisisco voto successivo:
            System.out.println("Dgt voto oppure -1 per finire: ");
            voto = input.nextInt();

        }// fine while

        // se utente ha inserito almeno 1 voto:
        if (cntVoti != 0) {
            // calcolo della media voti
            media = (double) tot / cntVoti; // divisione

            // visualizzazione calcoli
            System.out.printf("\nIl totale dei voti risulta: %d\n", cntVoti);
            System.out.printf("La media voti risulta: %.2f\n", media);
        }// fine if
        else{
            System.out.println("Non sono stati inseriti voti.");
        }

    }//fine metodo calcolaMediaVoti
}// fine classe

10° Applicazione: Bonifico su Conto.

/**
 * Classe Conto
 * con costruttore per inizializzare il saldo.
 * @author roberto
 *
 */
public class Conto {
   
    // definizione variabile saldo presente
    private double saldo;
   
    //costruttore
    public Conto( double saldoPresente ){
        // verifico che saldo presente sia maggiore di 0.0;
        // se non lo é lo si inizializza a 0.0
        if( saldoPresente > 0.0 ) saldo = saldoPresente;
   
    }// fine costruttore
   
    // deposito cifra sul conto
    public void deposito(double euro){
        saldo += saldo+euro;
    }

    // restituisce il saldo presente sul conto
    public double getSaldo() {
        return saldo;
    }
}

9° Applicazione: Classe con costruttore per inizializzare nome del catalogo.

public class Catalogo4 {

    // ----------------------------------------------- Definizione attributi
    private String nomeCatalogo;
   
    // ---------------------------------- Costruttore che inizializza il nome del catalogo
    public Catalogo4(String nome){
        nomeCatalogo = nome;
    }// fine costruttore   

    // ----------------------------------------------- Metodi get e set
    public String getNomeCatalogo() {
        return nomeCatalogo;
    }

    public void setNomeCatalogo(String nomeCat) {
        this.nomeCatalogo = nomeCat;
    }

    // ----------------------------------------------- Mostra un messaggio
    // all'utente
    public void visualizzaMessaggio(String nomeCat) {
        System.out.printf("--- Benvenuti nel catalogo 4: %s !\n ",
                getNomeCatalogo());
    }
}

8° Applicazione: Classe con metodi get e set.

public class Catalogo3 {

    // ----------------------------------------------- Definizione attributi
    private String nomeCatalogo;

    // ----------------------------------------------- Metodi get e set
    public String getNomeCatalogo() {
        return nomeCatalogo;
    }

    public void setNomeCatalogo(String nomeCat) {
        this.nomeCatalogo = nomeCat;
    }

    // ----------------------------------------------- Mostra un messaggio all'utente
    public void visualizzaMessaggio(String nomeCat) {
        System.out.printf("--- Benvenuti nel catalogo 3: %s !\n ", getNomeCatalogo());
    }

}

7° Applicazione: Dichiarazione metodo con parametro.

public class Catalogo2 {

    // mostra un messaggio all'utente
    public void visualizzaMessaggio(String nomeCatalogo) {
        System.out.printf("--- Benvenuti nel catalogo \n%s!\n ---", nomeCatalogo);
    }
}

6° Applicazione: Classi ed oggetti.

/**
 * Dichiarazione di classe
 * con un metodo
 * @author roberto
 *
 */
public class Catalogo {

    // mostra un messaggio all'utente
    public void visualizzaMessaggio(){
        System.out.println("--- Benvenuti nel catalogo ---");
    }
}

5° Applicazione: Confrontare due numeri interi.

import java.util.Scanner;

public class ComparareDueInteri {

    public static void main(String[] args) {
       
        // creo Scanner
        Scanner input = new Scanner(System.in);
       
        // definisco 2 variabili tipo intero
        int num1;
        int num2;
       
        // richiesta dei numeri ad utente:
        System.out.println("Digitare primo numero intero: ");
        num1 = input.nextInt();
       
        System.out.println("Digitare secondo numero intero: ");
        num2 = input.nextInt();
       
        // inizio il confronto
        if(num1 == num2) System.out.printf("%d == %d\n", num1, num2);
        if(num1 != num2) System.out.printf("%d diverso da %d", num1, num2);
    }
}

Documentazione API di java:

• API Java 6
• API Java 7 
• API Java 8 

4° Applicazione: Somma di tre numeri interi.

import java.util.Scanner;

public class Somma {

    public static void main(String[] args) {
       
        // creazione Scanner
        Scanner input = new Scanner(System.in);
       
        int num1;    // primo addendo
        int num2;    // secondo addendo
        int num3;    // terzo addendo
        int somma;    // somma i tre numeri
       
        System.out.println("Digitare 1 numero intero: ");    // input
        num1 = input.nextInt();    // legge 1 addendo
       
        System.out.println("Digitare 2 numero intero: ");    // input
        num2 = input.nextInt();    // legge 2 addendo
       
        System.out.println("Digitare 3 numero intero: ");    // input
        num3 = input.nextInt();    // legge 3 addendo
       
        somma = num1 + num2 + num3;
       
        // stampo a console la somma eseguita:
        System.out.printf("La somma risulta: %d\n", somma);
    }
}

3° Applicazione: Stampare testo con printf.

public class Benvenuto3 {

    public static void main(String[] args) {
        // altro metodo di stampa a video: printf
        System.out.printf( "%s\n%s\n", "Benvenuto al corso", "base di java!");
    }
}

2° Applicazione: Stampare singola riga di testo con più istruzioni.

public class Benvenuto2 {

    public static void main(String[] args) {
       
        // primo metodo di stampa a video: print
        System.out.print("Benvenuto al");
        // secondo metodo di stampa a video, con salto alla riga successiva: println
        System.out.println(" secondo esempio del corso base di: Java! ");
    }
}

1° applicazione Java: Stampare una riga di testo :-)

public class Benvenuto
{
   // metodo main da dove inizia l'esecuzione dell'applicazione
   public static void main(String args[])
   {
      System.out.println( "Benvenuto al corso base di Java." );
   }// fine metodo main

}// fine classe Benvenuto