Esercizi Override e Overload in Java

Ecco degli esercizi con soluzione per praticare l’uso di override e overload in Java.

Esercizi sull’Override

Esercizio 1: Override di un Metodo

Creare una classe base `Animale` con un metodo `suono` e una classe derivata `Cane` che sovrascrive il metodo `suono`.

class Animale {
    public void suono() {
        System.out.println("L'animale fa un suono");
    }
}

class Cane extends Animale {
    @Override
    public void suono() {
        System.out.println("Il cane abbaia");
    }
}

public class TestOverride {
    public static void main(String[] args) {
        Animale mioAnimale = new Animale();
        Animale mioCane = new Cane();

        mioAnimale.suono();
        mioCane.suono();
    }
}

Esercizio 2: Chiamata al Metodo Sovrascritto

Creare una classe `Gatto` che sovrascrive il metodo `suono` della classe `Animale` e chiama il metodo sovrascritto della superclasse.

class Animale {
    public void suono() {
        System.out.println("L'animale fa un suono");
    }
}

class Gatto extends Animale {
    @Override
    public void suono() {
        super.suono();
        System.out.println("Il gatto miagola");
    }
}

public class TestOverride {
    public static void main(String[] args) {
        Animale mioGatto = new Gatto();
        mioGatto.suono();
    }
}

Esercizio 3: Override di un Metodo con Differente Visibilità

Sovrascrivere un metodo della classe `Animale` nella classe `Uccello` aumentando la visibilità del metodo.

class Animale {
    void suono() {
        System.out.println("L'animale fa un suono");
    }
}

class Uccello extends Animale {
    @Override
    public void suono() {
        System.out.println("L'uccello cinguetta");
    }
}

public class TestOverride {
    public static void main(String[] args) {
        Animale mioUccello = new Uccello();
        mioUccello.suono();
    }
}

Esercizio 4: Override di un Metodo `toString`

Sovrascrivere il metodo `toString` in una classe `Persona` per restituire una rappresentazione personalizzata dell'oggetto.

class Persona {
    private String nome;
    private int eta;

    public Persona(String nome, int eta) {
        this.nome = nome;
        this.eta = eta;
    }

    @Override
    public String toString() {
        return "Nome: " + nome + ", Età: " + eta;
    }
}

public class TestOverride {
    public static void main(String[] args) {
        Persona persona = new Persona("Mario", 30);
        System.out.println(persona);
    }
}

Esercizi sull’Overload

Esercizio 5: Overload di un Metodo

Creare una classe `Calcolatrice` con metodi sovraccaricati `somma` che accettano differenti numeri di parametri.

class Calcolatrice {
    public int somma(int a, int b) {
        return a + b;
    }

    public int somma(int a, int b, int c) {
        return a + b + c;
    }

    public double somma(double a, double b) {
        return a + b;
    }
}

public class TestOverload {
    public static void main(String[] args) {
        Calcolatrice calc = new Calcolatrice();

        System.out.println("Somma di 2 interi: " + calc.somma(5, 10));
        System.out.println("Somma di 3 interi: " + calc.somma(5, 10, 15));
        System.out.println("Somma di 2 double: " + calc.somma(5.5, 10.5));
    }
}

Esercizio 6: Overload di un Costruttore

Creare una classe `Rettangolo` con costruttori sovraccaricati che accettano differenti numeri di parametri.

class Rettangolo {
    private int larghezza;
    private int altezza;

    public Rettangolo(int larghezza, int altezza) {
        this.larghezza = larghezza;
        this.altezza = altezza;
    }

    public Rettangolo(int lato) {
        this.larghezza = lato;
        this.altezza = lato;
    }

    public int area() {
        return larghezza * altezza;
    }
}

public class TestOverload {
    public static void main(String[] args) {
        Rettangolo rett1 = new Rettangolo(5, 10);
        Rettangolo rett2 = new Rettangolo(7);

        System.out.println("Area del rettangolo 1: " + rett1.area());
        System.out.println("Area del rettangolo 2: " + rett2.area());
    }
}

Esercizio 7: Overload con Differenti Tipi di Parametri

Creare una classe `Stampante` con metodi sovraccaricati `stampa` che accettano differenti tipi di parametri.

class Stampante {
    public void stampa(String testo) {
        System.out.println("Stringa: " + testo);
    }

    public void stampa(int numero) {
        System.out.println("Intero: " + numero);
    }

    public void stampa(double numero) {
        System.out.println("Double: " + numero);
    }
}

public class TestOverload {
    public static void main(String[] args) {
        Stampante stampante = new Stampante();

        stampante.stampa("Ciao, mondo!");
        stampante.stampa(100);
        stampante.stampa(99.99);
    }
}

Esercizio 8: Overload e Override Combinati

Creare una classe `Veicolo` con un metodo `muovi` e una classe derivata `Auto` che sovrascrive `muovi` e aggiunge metodi sovraccaricati `muovi`.

class Veicolo {
    public void muovi() {
        System.out.println("Il veicolo si sta muovendo");
    }
}

class Auto extends Veicolo {
    @Override
    public void muovi() {
        System.out.println("L'auto si sta muovendo");
    }

    public void muovi(int velocita) {
        System.out.println("L'auto si sta muovendo a " + velocita + " km/h");
    }

    public void muovi(int velocita, String direzione) {
        System.out.println("L'auto si sta muovendo a " + velocita + " km/h verso " + direzione);
    }
}

public class TestOverrideOverload {
    public static void main(String[] args) {
        Auto miaAuto = new Auto();
        miaAuto.muovi();
        miaAuto.muovi(60);
        miaAuto.muovi(80, "nord");
    }
}