Classe squadra con calciatore e portiere con ereditarietà in Java

Creare una gerarchia di classi come nel diagramma UML in foto per Calciatore e Portiere. Prevedere gli attributi, metodi di accesso set/get (non indicati per brevità), costruttori e metodi accessori come da schema. Dare particolare attenzione a overloading e override di costruttori e metodi. Creare quindi una classe main di test che funge da black box ed implementare le seguenti richieste;

Parte 1

• crea l’istanza c1 di tipo Calciatore e p1 di tipo Portiere;
• visualizzi i dati del Calciatore c1 e del portiere p1;
• visualizzare il nome di quale dei due atleti ha giocato più partite;
• per il portiere p1 visualizzare il messaggio “Ottimo” se il numero di rigori parati è pari almeno alla metà dei rigori subiti;
• per il calciatore c1, visualizzare la media gol a partita

Parte 2

Implementiamo la restante porzione di UML realizzando la classe Squadra che gestisce più calciatori con un ArrayList. Realizzare i seguenti metodi:

• inserisciCalciatore(Calciatore): void – Aggiunge un calciatore di tipo oggetto all’arraylist
• cerca(nome): int – Cerca un calciatore per nome passato come parametro e restituisce la posizione indice dell’arraylist
• modifica(nome): Calciatore – Cerca un calciatore per nome passato come parametro e restituisce l’oggetto corrispondente
• rimuoviCalciatore(int): void – Prende il Calciatore in posizione passata da parametro e lo cancella
• rimuoviCalciatore(String): void – Cerca un calciatore per nome e lo rimuove
• stampaRosa(): void – Stampa le informazioni di tutti i calciatori in rosa. Stampare anche il ruolo (usa instanceof)
• valoreInEuroSquadra(): int; restituisce il totale somma dei valori in euro di tutti i calciatori in rosa
• calciatoreConPiùGol(): Calciatore – Restituisce l’oggetto calciatore che ha più gol fatti in rosa

Nel main, testare ciascuno dei metodi appena implementati inserendo un congruo numero di calciatori/portieri nella rosa.

Classe Calciatore

Codice piuttosto semplice. Invito a riflettere sul metodo di stampa r l media gol con lo stratagemma di troncare il numero decimale al .quaderno

public class Calciatore
{
    private String nome;
    private int partiteGiocate;
    private int golSegnati;
    private long valoreinEuro;

    //COSTRUTTORI
    public Calciatore() { }

    public Calciatore(String nome, int partiteGiocate, int golSegnati, long valoreinEuro)
    {
        this.nome = nome;
        this.partiteGiocate = partiteGiocate;
        this.golSegnati = golSegnati;
        this.valoreinEuro = valoreinEuro;
    }

    public Calciatore(Calciatore c)
    {
        this.nome = c.getNome();
        this.partiteGiocate = c.getPartiteGiocate();
        this.golSegnati = c.getGolSegnati();
        this.valoreinEuro = c.getValoreinEuro();
    }

    //METODI DI ACCESSO


    public String getNome() {
        return nome;
    }

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

    public int getPartiteGiocate() {
        return partiteGiocate;
    }

    public void setPartiteGiocate(int partiteGiocate) {
        this.partiteGiocate = partiteGiocate;
    }

    public int getGolSegnati() {
        return golSegnati;
    }

    public void setGolSegnati(int golSegnati) {
        this.golSegnati = golSegnati;
    }

    public long getValoreinEuro() {
        return valoreinEuro;
    }

    public void setValoreinEuro(long valoreinEuro) {
        this.valoreinEuro = valoreinEuro;
    }

    //METODI ACCESSORI
    public void stampaInfo()
    {
        System.out.println("|-------------------------------------|");
        System.out.println("|              CALCIATORE             |");
        System.out.println("|-------------------------------------|");
        System.out.println("| Nome            : " + String.format("%-18s", this.nome) + "|");
        System.out.println("| # Gol segnati   : " + String.format("%-18s", this.golSegnati) + "|");
        System.out.println("| # Presenza      : " + String.format("%-18s", this.partiteGiocate) + "|");
        System.out.println("| # Media Gol     : " + String.format("%-18s", this.mediaGol()) + "|");
        System.out.println("| # Valore        : " + String.format("%-18s", this.valoreinEuro) + "|");
        System.out.println("|-------------------------------------|");
    }

    public double mediaGol()
    {
        double media = 0;

        media = (double)this.golSegnati / (double)this.partiteGiocate;
        media = Math.round(media * 100.0)/100.0;
        return media;
    }
}

Classe Portiere

Eredita da calciatore quindi occhio all’utilizzo di super per richiamare metodi del padre.

public class Portiere extends Calciatore
{
    private int golSubiti;
    private int rigoriSubiti;
    private int rigoriParati;

    public  Portiere()
    {
        super();
    }

    //COSTRUTTORI
    public Portiere(String nome,
                    int partiteGiocate,
                    int golSegnati,
                    long valoreinEuro,
                    int golSubiti, int rigoriSubiti, int rigoriParati)
    {
        super(nome, partiteGiocate, golSegnati, valoreinEuro);
        this.golSubiti = golSubiti;
        this.rigoriSubiti = rigoriSubiti;
        this.rigoriParati = rigoriParati;
    }

    public Portiere(Portiere p)
    {
        //this.setNome(p.getNome());
        //this.setPartiteGiocate(p.getPartiteGiocate());
        //this.setPartiteGiocate(p.getGolSegnati());
        //this.setValoreinEuro(p.getValoreinEuro());
        //possono
        super(p);
        this.golSubiti = p.getGolSubiti();
        this.rigoriParati = p.getRigoriParati();
        this.rigoriSubiti = p.getRigoriSubiti();
    }

    //METODI DI ACCESSO

    public int getGolSubiti() {
        return golSubiti;
    }

    public void setGolSubiti(int golSubiti) {
        this.golSubiti = golSubiti;
    }

    public int getRigoriSubiti() {
        return rigoriSubiti;
    }

    public void setRigoriSubiti(int rigoriSubiti) {
        this.rigoriSubiti = rigoriSubiti;
    }

    public int getRigoriParati() {
        return rigoriParati;
    }

    public void setRigoriParati(int rigoriParati) {
        this.rigoriParati = rigoriParati;
    }

    //METODI ACCESSORI
    public void stampaInfo()
    {
        System.out.println("|-------------------------------------|");
        System.out.println("|              PORTIERE               |");
        System.out.println("|-------------------------------------|");
        System.out.println("| Nome            : " + String.format("%-18s", this.getNome()) + "|");
        System.out.println("| # Gol segnati   : " + String.format("%-18s", this.getGolSegnati()) + "|");
        System.out.println("| # Presenza      : " + String.format("%-18s", this.getPartiteGiocate()) + "|");
        System.out.println("| # Media Gol     : " + String.format("%-18s", this.mediaGol()) + "|");
        System.out.println("| # Gol subiti    : " + String.format("%-18s", this.golSubiti) + "|");
        System.out.println("| # Rigori parati : " + String.format("%-18s", this.rigoriParati) + "|");
        System.out.println("| # Rigori subiti : " + String.format("%-18s", this.rigoriSubiti)+ "|");
        System.out.println("| # Valore        : " + String.format("%-18s", this.getValoreinEuro()) + "|");
        System.out.println("|-------------------------------------|");
    }
}

Classe Squadra

Ed eccoci alla classe che gestisce i nostri oggetti portiere e calciatore. Non ha particolari sorprese o difficoltà. La gestione degli ArrayList passa sempre attraverso dei metodi accessori tra cui la ricerca, inserimento e cancellazione, modifica che sono pressoché sempre gli stessi. Interessante è la stampa cumulativa della rosa. L’arraylist infatti è di tipo Calciatore, ma per le regole del polimorfismo, posso metterci dentro anche i figli di tipo Portiere. Il problema sta che se chiamiamo la stampaInfo, verrà sempre chiamata quella implementata in Calciatore. Occorre stabile se la istanza in analisi sia un Calciatore o Portiere attraverso la chiave “instance of“. Gli altri metodi per la somma totale dei valori di ogni singolo calciatore, richiede come giusto che sia di prelevare il valore con l’opportuno metodo di accesso per accumularlo in una variabile somma. Il metodo che ci restituisce il calciatore con più gol non dovrebbe spaventare, si ragiona sempre su un valore numerico ma si mette da parte l’intero oggetto corrispondente.

public class Squadra
{
    private String nome;
    private int annoFondazione;
    private ArrayList<Calciatore> rosa;

    public Squadra()
    {
        this.rosa = new ArrayList<Calciatore>();
    }

    public Squadra(String nome, int annoFondazione)
    {
        this();
        this.nome = nome;
        this.annoFondazione = annoFondazione;
    }

    public String getNome() {
        return nome;
    }

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

    public int getAnnoFondazione() {
        return annoFondazione;
    }

    public void setAnnoFondazione(int annoFondazione) {
        this.annoFondazione = annoFondazione;
    }

    //METODI ACCESSORI
    public void inserisciCalciatore(Calciatore c)
    {
        if (c != null)
        {
            this.rosa.add(c);
        }
    }

    public int cerca(String _nome)
    {
        for(int i=0; i < this.rosa.size(); i++)
        {
            if (this.rosa.get(i).getNome() == _nome)
            {
                return i;   //restituisce l'indice del calciatore trovato
            }
        }

        return -1;
    }

    public Calciatore modifica(String _nome)
    {
        for(int i=0; i < this.rosa.size(); i++)
        {
            if (this.rosa.get(i).getNome() == _nome)
            {
                return this.rosa.get(i);
            }
        }

        return null;
    }

    public void rimuoviCalciatore(int index)
    {
        this.rosa.remove(index);
    }

    public void rimuoviCalciatore(String _nome)
    {
        for(int i=0; i < this.rosa.size(); i++)
        {
            if (this.rosa.get(i).getNome() == _nome)
            {
                this.rosa.remove(i);
            }
        }

    }

    public void stampaRosa()
    {
        for(int i=0; i < this.rosa.size(); i++)
        {
            if (this.rosa.get(i) instanceof Portiere)
            {
                Portiere p = (Portiere)this.rosa.get(i);
                p.stampaInfo();
            }
            else
                this.rosa.get(i).stampaInfo();
            System.out.println();
        }
    }

    public long valoreInEuroSquadra()
    {
        long valore = 0;
        for(int i=0; i < this.rosa.size(); i++)
        {
            valore += this.rosa.get(i).getValoreinEuro();
        }

        return valore;
    }

    public Calciatore calciatoreConPiuGol()
    {
        Calciatore max = null;

        for(int i=0; i < this.rosa.size(); i++)
        {
            if (this.rosa.get(i).getGolSegnati() > max.getGolSegnati())
            {
                max = this.rosa.get(i);
            }
        }

        return max;
    }
}

Classe Main

Il metodo main risponde alle richieste dell’esercizio. C’è solo un briciolo di gestione dell’output un filo ordinata con testi ed andate a capo per rendere tutto più leggibile.

public class Main
{
    public static void main(String[] args)
    {
        /*** PARTE 1 ***/
        Calciatore c1 = new Calciatore("Gabriel Batistuta", 200,95,20000000);
        Portiere p1 = new Portiere("Sebastiano Rossi", 345,0,7000000,145,50,42);

        c1.stampaInfo();
        System.out.println();
        p1.stampaInfo();
        System.out.println();

        if (c1.getPartiteGiocate() > p1.getPartiteGiocate())
        {
            System.out.print(c1.getNome() + " ha giocato più partite di "+ p1.getNome());
        }
        else
        {
            System.out.print(p1.getNome() + " ha giocato più partite di "+ c1.getNome());
        }

        System.out.println();

        if (p1.getRigoriParati() >= p1.getRigoriSubiti()/2)
        {
            System.out.print("Ottimo! " + p1.getNome() + " ha parato più rigori di quanti subiti");
        }

        /*** PARTE 2 ***/
        Squadra milan = new Squadra("Milan", 1899);
        milan.inserisciCalciatore(c1);
        milan.inserisciCalciatore(p1);
        milan.inserisciCalciatore(new Calciatore("Zlatan Ibrahimovic",23,8,4000000 ));
        milan.inserisciCalciatore(new Portiere("Dida",21,0,12000000,12,10,12));
        System.out.println();

        int posizione = milan.cerca("Zlatan Ibrahimovic");
        if (posizione > 0)
        {
            System.out.println("Zlatan Ibrahimovic trovato in posizione "+ posizione);
        }
        else
        {
            System.out.println("Zlatan Ibrahimovic non trovato");
        }

        System.out.println();
        milan.stampaRosa();
        System.out.println();

        System.out.println("Cancella Batistuta e Dida e ristampa la rosa");
        milan.rimuoviCalciatore(0);
        milan.rimuoviCalciatore("Dida");

        System.out.println();
        milan.stampaRosa();
        System.out.println();
    }
}

Listati

GitHub -> qui

Ultima modifica 30 Dicembre 2022

Articoli simili:

Classe angolo in Java Esempio Java: classe Impiegato Classe Telefonata con gestione su SIM Form studente con JavaFX