Implementación de Interfaces

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 35 de 87.

Para usar una interfaz, una clase debe implementarla mediante la palabra clave implements. Después, la clase proporciona implementaciones concretas para todos los métodos declarados en la interfaz:

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);
    }
}

Si una clase implementa una interfaz, pero no proporciona implementaciones para todos sus métodos, el compilador generará un error. La anotación @Override es opcional, pero se recomienda, ya que ayuda a detectar errores.

Al igual que con las clases abstractas, puedes usar una interfaz como tipo de referencia. Esto permite el polimorfismo, donde distintas clases que implementan la misma interfaz pueden tratarse de manera uniforme:

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

shape1.draw();  // Dibujando un círculo con radio 5.0
shape2.draw();  // Dibujando un rectángulo 4.0 x 3.0

Esto es potente porque el código que trabaja con referencias a Drawable no necesita conocer el tipo de clase específico. Solo le importa que el objeto se pueda dibujar.

En la próxima lección, verás cómo una sola clase puede implementar varias interfaces simultáneamente.

Desafío

Fácil

Construyamos un sistema de altavoces que demuestre cómo las clases implementan interfaces. Crearás una interfaz que define lo que cualquier altavoz puede hacer y, después, crearás dos tipos diferentes de altavoz que implementen este contrato a su manera.

Organizarás tu código en cuatro archivos:

Speaker.java: Define una interfaz llamada Speaker que declare lo que cualquier altavoz debe poder hacer. Todo altavoz debe tener un método speak() que devuelva un String. Este es el contrato que todas las clases que lo implementen deben cumplir.
Human.java: Crea una clase que implemente la interfaz Speaker. Un Human tiene un campo name (String). Incluye un constructor para inicializar el nombre e implementa el método speak() para que devuelva: [name] says: Hello everyone!
Robot.java: Crea otra clase que implemente la interfaz Speaker. Un Robot tiene un campo model (String). Incluye un constructor para inicializar el modelo e implementa el método speak() para que devuelva: Robot [model] says: Beep boop!
Main.java: Une todo mediante polimorfismo basado en interfaces. Recibirás dos entradas: un nombre humano y un modelo de robot. Crea un Human y un Robot, y después guárdalos en un array de referencias Speaker. Recorre el array e imprime el resultado de llamar a speak() en cada altavoz.

Recibirás dos entradas: el nombre del humano (String) y el modelo del robot (String).

Tu salida debe mostrar dos líneas: una por cada altavoz. ¡Observa cómo tanto Human como Robot pueden tratarse de manera uniforme mediante la interfaz Speaker, aunque hablen de formas completamente diferentes!

REQUIRED OUTPUT FORMAT: [Tu contenido traducido aquí]

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer las entradas
        String humanName = scanner.nextLine();
        String robotModel = scanner.nextLine();
        
        // TODO: Crear un objeto Human con el nombre dado
        
        // TODO: Crear un objeto Robot con el modelo dado
        
        // TODO: Crear un array de referencias Speaker que contenga ambos objetos
        
        // TODO: Recorrer el array e imprimir el resultado de speak() para cada speaker
    }
}