Implementando Interfaces

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 35 de 87.

Para usar uma interface, uma classe deve implementá-la usando a palavra-chave implements. Em seguida, a classe fornece implementações concretas para todos os métodos declarados na interface:

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 uma classe implementa uma interface, mas não fornece implementações para todos os seus métodos, o compilador gerará um erro. A anotação @Override é opcional, mas recomendada, pois ajuda a detectar erros.

Assim como acontece com classes abstratas, você pode usar uma interface como um tipo de referência. Isso possibilita o polimorfismo, no qual diferentes classes que implementam a mesma interface podem ser tratadas de maneira uniforme:

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

shape1.draw();  // Desenhando um círculo com raio 5.0
shape2.draw();  // Desenhando um retângulo 4.0 x 3.0

Isso é poderoso porque o código que trabalha com referências a Drawable não precisa conhecer o tipo específico da classe. Ele só precisa saber que o objeto pode ser desenhado.

Na próxima lição, você verá como uma única classe pode implementar várias interfaces simultaneamente.

Desafio

Fácil

Vamos criar um sistema de alto-falantes que demonstra como as classes implementam interfaces. Você criará uma interface que define o que qualquer alto-falante pode fazer e, em seguida, criará dois tipos diferentes de alto-falantes que implementam esse contrato à sua própria maneira.

Você organizará seu código em quatro arquivos:

Speaker.java: Defina uma interface chamada Speaker que declare o que qualquer alto-falante deve ser capaz de fazer. Todo alto-falante deve ter um método speak() que retorne uma String. Esse é o contrato que todas as classes que o implementarem devem cumprir.
Human.java: Crie uma classe que implemente a interface Speaker. Um Human tem um campo name (String). Inclua um construtor para inicializar o nome e implemente o método speak() para retornar: [name] says: Hello everyone!
Robot.java: Crie outra classe que implemente a interface Speaker. Um Robot tem um campo model (String). Inclua um construtor para inicializar o modelo e implemente o método speak() para retornar: Robot [model] says: Beep boop!
Main.java: Reúna tudo usando polimorfismo baseado em interfaces. Você receberá duas entradas: um nome de humano e um modelo de robô. Crie um Human e um Robot e, em seguida, armazene-os em um array de referências Speaker. Percorra o array e imprima o resultado da chamada de speak() em cada alto-falante.

Você receberá duas entradas: o nome do humano (String) e o modelo do robô (String).

Sua saída deve mostrar duas linhas: uma para cada alto-falante. Observe como tanto o Human quanto o Robot podem ser tratados uniformemente por meio da interface Speaker, embora falem de maneiras completamente diferentes!

REQUERIDO FORMATO DE SAÍDA: [Seu conteúdo traduzido aqui]

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Ler entradas
        String humanName = scanner.nextLine();
        String robotModel = scanner.nextLine();
        
        // TODO: Crie um objeto Human com o nome fornecido
        
        // TODO: Crie um objeto Robot com o modelo fornecido
        
        // TODO: Crie um array de referências Speaker contendo ambos os objetos
        
        // TODO: Percorra o array e imprima o resultado de speak() para cada speaker
    }
}