Introduzione alle interfacce

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

Hai visto come le classi astratte definiscono contratti che le sottoclassi devono rispettare. Ma cosa succede se vuoi che una classe rispetti più contratti? Java non permette a una classe di estendere più classi, ma risolve questo problema con le interfacce.

Un'interfaccia è un contratto che definisce cosa può fare una classe, senza specificare come lo fa. A differenza delle classi astratte, le interfacce contengono solo firme dei metodi (per impostazione predefinita), senza implementazione:

public interface Drawable {
    void draw();
}

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

Considera un'interfaccia come una promessa. Quando una classe implementa un'interfaccia, promette di fornire implementazioni per tutti i metodi dichiarati in quell'interfaccia. L'interfaccia definisce la capacità e la classe fornisce il comportamento.

Le interfacce vengono dichiarate usando la parola chiave interface invece di class. Tutti i metodi in un'interfaccia sono implicitamente public e abstract, quindi non devi scrivere queste parole chiave:

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

Le interfacce possono anche dichiarare costanti, che sono implicitamente public static final:

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

Nella prossima lezione imparerai come le classi implementano le interfacce usando la parola chiave implements.

Sfida

Facile

Costruiamo un sistema di controllo dei dispositivi definendo interfacce che descrivono cosa possono fare i diversi dispositivi. Questa sfida si concentra sulla creazione di interfacce: i contratti che definiscono le capacità senza specificare come funzionano.

Organizzerai il codice in tre file:

Switchable.java: crea un'interfaccia che definisce cosa significa che un dispositivo è commutabile. Qualsiasi dispositivo commutabile dovrebbe poter essere acceso e spento. Dichiara due metodi: turnOn() e turnOff(). Ricorda: i metodi delle interfacce sono implicitamente public e abstract, quindi ti bastano le firme dei metodi.
Adjustable.java: crea un'altra interfaccia che definisce cosa significa che un dispositivo è regolabile. Un dispositivo regolabile dovrebbe poter impostare il proprio livello. Dichiara un metodo setLevel(int level). Includi anche una costante MAX_LEVEL con valore 100: ricorda che le costanti nelle interfacce sono implicitamente public static final.
Main.java: dimostra che le tue interfacce sono definite correttamente stampando informazioni su di esse. Riceverai un input: un valore di livello (int). Stampa le seguenti tre righe:
- Switchable methods: turnOn, turnOff
- Adjustable methods: setLevel
- Max level constant: [MAX_LEVEL value] (accedi alla costante dall'interfaccia Adjustable)
Poi stampa: Setting level to: [input level]

Riceverai un input: un valore di livello (int).

Questa sfida si concentra esclusivamente sulla definizione delle interfacce: i progetti che descrivono le capacità. Nella prossima lezione imparerai come le classi implementano effettivamente queste interfacce per fornire il comportamento reale!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int level = scanner.nextInt();
        
        // TODO: Stampa informazioni sulle interfacce
        // Stampa: "Switchable methods: turnOn, turnOff"
        // Stampa: "Adjustable methods: setLevel"
        // Stampa: "Max level constant: " seguito da Adjustable.MAX_LEVEL
        // Stampa: "Setting level to: " seguito dal livello inserito
        
    }
}