Interfacce e Costanti in Java

Concetti Chiave

Le interfacce possono essere utilizzate per definire costanti condivise tra più classi.
Le interfacce che non contengono metodi possono essere utilizzate per importare costanti in uno spazio dei nomi comune.

Costanti nelle Interfacce

È possibile usare le interfacce per importare costanti condivise in più classi semplicemente dichiarando un'interfaccia che contiene variabili inizializzate con i valori desiderati.

Quando includiamo quell'interfaccia in una classe (cioè, quando si “implementa” l'interfaccia), tutti quei nomi di variabili saranno disponibili come costanti.

Se un'interfaccia non contiene metodi, allora qualsiasi classe che include un'interfaccia di questo tipo in realtà non implementa nulla. È come se quella classe stesse importando i campi costanti nello spazio dei nomi della classe come variabili final.

Il prossimo esempio utilizza questa tecnica per implementare un “decisore” automatizzato:

import java.util.Random;

interface CostantiCondivise {
    int NO = 0;
    int SI = 1;
    int FORSE = 2;
    int PIU_TARDI = 3;
    int PRESTO = 4;
    int MAI = 5;
}

class Domanda implements CostantiCondivise {
    Random casuale = new Random();

    int chiedi() {
        int probabilita = (int) (100 * casuale.nextDouble());
        if (probabilita < 30)
            return NO;        // 30%
        else if (probabilita < 60)
            return SI;        // 30%
        else if (probabilita < 75)
            return PIU_TARDI; // 15%
        else if (probabilita < 98)
            return PRESTO;    // 13%
        else
            return MAI;       // 2%
    }
}

class ChiediAMe implements CostantiCondivise {
    static void rispondi(int risultato) {
        switch(risultato) {
            case NO:
                System.out.println("No");
                break;
            case SI:
                System.out.println("Sì");
                break;
            case FORSE:
                System.out.println("Forse");
                break;
            case PIU_TARDI:
                System.out.println("Più tardi");
                break;
            case PRESTO:
                System.out.println("Presto");
                break;
            case MAI:
                System.out.println("Mai");
                break;
        }
    }

    public static void main(String[] args) {
        Domanda d = new Domanda();

        rispondi(d.chiedi());
        rispondi(d.chiedi());
        rispondi(d.chiedi());
        rispondi(d.chiedi());
    }
}

Si noti che questo programma utilizza una delle classi standard di Java: Random. Questa classe fornisce numeri pseudocasuali. Contiene diversi metodi che permettono di ottenere numeri casuali nel formato richiesto dal programma. In questo esempio viene usato il metodo nextDouble(). Restituisce numeri casuali nell'intervallo da 0.0 a 1.0.

In questo esempio, le due classi, Domanda e ChiediAMe, implementano entrambe l'interfaccia CostantiCondivise in cui sono definiti NO, SI, FORSE, PRESTO, PIU_TARDI e MAI.

All'interno di ciascuna classe, il codice fa riferimento a queste costanti come se ogni classe le avesse definite o ereditate direttamente. Ecco l'output di un'esecuzione di esempio di questo programma. Si noti che i risultati sono diversi ogni volta che viene eseguito.

Più tardi
Presto
No
Sì

Consiglio

Uso controverso delle interfacce per costanti

La tecnica di usare un'interfaccia per definire costanti condivise, come appena descritto, è controversa. È qui descritta solo per completezza.