Implementazione delle interfacce

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 35 di 87.

Per usare un'interfaccia, una classe deve implementarla usando la parola chiave implements. La classe fornisce quindi implementazioni concrete per tutti i metodi dichiarati nell'interfaccia:

public interface Drawable {
    void draw();
}

public class Circle implements Drawable {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }
}

Se una classe implementa un'interfaccia ma non fornisce implementazioni per tutti i suoi metodi, il compilatore genererà un errore. L'annotazione @Override è facoltativa, ma consigliata perché aiuta a individuare gli errori.

Proprio come con le classi astratte, puoi usare un'interfaccia come tipo di riferimento. Questo consente il polimorfismo, per cui classi diverse che implementano la stessa interfaccia possono essere trattate in modo uniforme:

Drawable shape1 = new Circle(5.0);
Drawable shape2 = new Rectangle(4.0, 3.0);

shape1.draw();  // Disegno di un cerchio con raggio 5.0
shape2.draw();  // Disegno di un rettangolo 4.0 x 3.0

Questo è potente perché il codice che lavora con i riferimenti a Drawable non deve conoscere il tipo specifico della classe. Gli importa solo che l'oggetto possa essere disegnato.

Nella prossima lezione vedrai come una singola classe può implementare più interfacce contemporaneamente.

Sfida

Facile

Creiamo un sistema di altoparlanti che dimostri come le classi implementano le interfacce. Creerai un'interfaccia che definisce cosa può fare qualsiasi altoparlante, poi creerai due tipi diversi di altoparlanti, ognuno dei quali implementa questo contratto a modo suo.

Organizzerai il codice in quattro file:

Speaker.java: Definisci un'interfaccia chiamata Speaker che dichiara cosa deve poter fare qualsiasi altoparlante. Ogni altoparlante dovrebbe avere un metodo speak() che restituisce una String. Questo è il contratto che tutte le classi che implementano l'interfaccia devono rispettare.
Human.java: Crea una classe che implementa l'interfaccia Speaker. Un Human ha un campo name (String). Includi un costruttore per inizializzare il nome e implementa il metodo speak() affinché restituisca: [name] says: Hello everyone!
Robot.java: Crea un'altra classe che implementa l'interfaccia Speaker. Un Robot ha un campo model (String). Includi un costruttore per inizializzare il modello e implementa il metodo speak() affinché restituisca: Robot [model] says: Beep boop!
Main.java: Metti insieme ogni elemento usando il polimorfismo basato sulle interfacce. Riceverai due input: il nome di una persona e il modello di un robot. Crea un Human e un Robot, poi memorizzali in un array di riferimenti Speaker. Scorri l'array e stampa il risultato della chiamata a speak() su ciascun altoparlante.

Riceverai due input: il nome della persona (String) e il modello del robot (String).

L'output dovrebbe mostrare due righe: una per ogni altoparlante. Nota come sia Human sia Robot possano essere trattati in modo uniforme tramite l'interfaccia Speaker, anche se parlano in modi completamente diversi!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leggi gli input
        String humanName = scanner.nextLine();
        String robotModel = scanner.nextLine();
        
        // TODO: Crea un oggetto Human con il nome fornito
        
        // TODO: Crea un oggetto Robot con il modello fornito
        
        // TODO: Crea un array di riferimenti a Speaker contenente entrambi gli oggetti
        
        // TODO: Scorri l'array e stampa il risultato di speak() per ogni Speaker
    }
}