Introdução às Interfaces

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

Você viu como classes abstratas definem contratos que as subclasses devem seguir. Mas e se você quiser que uma classe siga vários contratos? Java não permite que uma classe estenda várias classes, mas resolve esse problema com interfaces.

Uma interface é um contrato que define o que uma classe pode fazer, sem especificar como ela faz isso. Diferentemente das classes abstratas, as interfaces contêm apenas assinaturas de métodos (por padrão), sem implementação:

public interface Drawable {
    void draw();
}

public interface Resizable {
    void resize(int width, int height);
}

Considere uma interface como uma promessa. Quando uma classe implementa uma interface, ela promete fornecer implementações para todos os métodos declarados nessa interface. A interface define a capacidade, e a classe fornece o comportamento.

As interfaces são declaradas usando a palavra-chave interface em vez de class. Todos os métodos em uma interface são implicitamente public e abstract, portanto você não precisa escrever essas palavras-chave:

public interface Playable {
    void play();    // implicitamente public abstract
    void pause();
    void stop();
}

As interfaces também podem declarar constantes, que são implicitamente public static final:

public interface GameConstants {
    int MAX_PLAYERS = 4;  // implicitamente public static final
}

Na próxima lição, você aprenderá como as classes implementam interfaces usando a palavra-chave implements.

Desafio

Fácil

Vamos criar um sistema de controle de dispositivos definindo interfaces que descrevem o que diferentes dispositivos podem fazer. Este desafio se concentra na criação de interfaces: os contratos que definem capacidades sem especificar como elas funcionam.

Você organizará seu código em três arquivos:

Switchable.java: crie uma interface que defina o que significa um dispositivo ser comutável. Qualquer dispositivo comutável deve ser capaz de ligar e desligar. Declare dois métodos: turnOn() e turnOff(). Lembre-se de que os métodos de uma interface são implicitamente públicos e abstratos, portanto você só precisa das assinaturas dos métodos.
Adjustable.java: crie outra interface que defina o que significa um dispositivo ser ajustável. Um dispositivo ajustável deve ser capaz de definir seu nível. Declare um método setLevel(int level). Inclua também uma constante MAX_LEVEL com o valor 100: lembre-se de que as constantes em interfaces são implicitamente public static final.
Main.java: demonstre que suas interfaces estão definidas corretamente imprimindo informações sobre elas. Você receberá uma entrada: um valor de nível (int). Imprima as três linhas a seguir:
- Switchable methods: turnOn, turnOff
- Adjustable methods: setLevel
- Max level constant: [MAX_LEVEL value] (acesse a constante a partir da interface Adjustable)
Em seguida, imprima: Setting level to: [input level]

Você receberá uma entrada: um valor de nível (int).

Este desafio se concentra exclusivamente na definição de interfaces: os modelos que descrevem capacidades. Na próxima lição, você aprenderá como as classes realmente implementam essas interfaces para fornecer o comportamento real!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int level = scanner.nextInt();
        
        // TODO: Imprimir informações sobre as interfaces
        // Print: "Switchable methods: turnOn, turnOff"
        // Print: "Adjustable methods: setLevel"
        // Print: "Max level constant: " followed by Adjustable.MAX_LEVEL
        // Print: "Setting level to: " followed by the input level
        
    }
}