Perché tutti i campi in un'interfaccia sono implicitamente statici e finali?

Sto solo cercando di capire perché tutti i campi definiti in un'interfaccia sono implicitamente statice final. L'idea di mantenere i campi staticha senso per me dato che non puoi avere oggetti di un'interfaccia ma perché lo sono final(implicitamente)?

Qualcuno sa perché i progettisti Java sono andati a creare i campi in un'interfaccia statice final?

Un'interfaccia non può avere un comportamento o uno stato perché ha lo scopo di specificare solo un contratto di interazione, nessun dettaglio di implementazione. "Nessun comportamento" viene applicato non consentendo i corpi di metodo / costruttore o blocchi di inizializzazione statici / istanza. "Nessuno stato" viene applicato consentendo solo i campi finali statici. Pertanto, la classe può avere uno stato (stato statico), ma lo stato dell'istanza non viene dedotto dall'interfaccia.

BTW: una costante in Java è definita da un campo finale statico (e per convenzione il nome utilizza UPPER_CASE_AND_UNDERSCORES).

Motivo dell'essere final

Qualsiasi implementazione può modificare il valore dei campi se non sono definiti come finali. Quindi diventerebbero parte dell'implementazione. Un'interfaccia è una specifica pura senza alcuna implementazione.

Motivo dell'essere static

Se sono statici, appartengono all'interfaccia e non all'oggetto, né al tipo di runtime dell'oggetto.

Ci sono un paio di punti sorvolati qui:

Solo perché i campi in un'interfaccia sono implicitamente statici finali non significa che debbano essere costanti in fase di compilazione, o addirittura immutabili. Puoi definire ad es

interface I {
  String TOKEN = SomeOtherClass.heavyComputation();
  JButton BAD_IDEA = new JButton("hello");
}

(Attenzione che farlo all'interno di una definizione di annotazione può confondere javac , in relazione al fatto che quanto sopra viene effettivamente compilato in un inizializzatore statico.)

Inoltre, la ragione di questa restrizione è più stilistica che tecnica, e molte persone vorrebbero vederla rilassata .

I campi devono essere statici perché non possono essere astratti (come possono fare i metodi). Poiché non possono essere astratti, gli implementatori non saranno in grado di fornire logicamente la diversa implementazione dei campi.

I campi devono essere definitivi, penso, perché i campi possono essere acceduti da molti implementatori diversi, quindi possono essere modificabili potrebbe essere problematico (come la sincronizzazione). Anche per evitare che venga reimplementato (nascosto).

Solo il mio pensiero.

Considero il requisito che i campi siano definitivi come indebitamente restrittivo e un errore dei progettisti del linguaggio Java. Ci sono momenti, ad esempio la gestione degli alberi, in cui è necessario impostare costanti nell'implementazione necessarie per eseguire operazioni su un oggetto del tipo di interfaccia. La selezione di un percorso di codice sulla classe di implementazione è un kludge. La soluzione alternativa che utilizzo è definire una funzione di interfaccia e implementarla restituendo un letterale:

public interface iMine {
    String __ImplementationConstant();
    ...
}

public class AClass implements iMine {
    public String __ImplementationConstant(){
        return "AClass value for the Implementation Constant";
    }
    ...
}

public class BClass implements iMine {
    public String __ImplementationConstant(){
        return "BClass value for the Implementation Constant";
    }
    ...
}

Tuttavia, sarebbe più semplice, più chiaro e meno incline a un'implementazione aberrante utilizzare questa sintassi:

public interface iMine {
    String __ImplementationConstant;
    ...
}

public class AClass implements iMine {
    public static String __ImplementationConstant =
        "AClass value for the Implementation Constant";
    ...
}

public class BClass implements iMine {
    public static String __ImplementationConstant =
        "BClass value for the Implementation Constant";
    ...
}

Specifiche, contratti ... L'istruzione macchina per l'accesso al campo utilizza l'indirizzo dell'oggetto più l'offset del campo. Poiché le classi possono implementare molte interfacce, non c'è modo di fare in modo che il campo dell'interfaccia non finale abbia lo stesso offset in tutte le classi che estendono questa interfaccia. Pertanto è necessario implementare un meccanismo diverso per l'accesso al campo: due accessi alla memoria (ottenere l'offset del campo, ottenere il valore del campo) invece di uno più il mantenimento del tipo di tabella del campo virtuale (analogo della tabella del metodo virtuale). Immagino che non volessero complicare jvm per funzionalità che possono essere facilmente simulate tramite roba (metodi) esistenti.

In scala possiamo avere campi nelle interfacce, sebbene internamente siano implementati come ho spiegato sopra (come metodi).

static:

Nulla (variabile o metodo) che è staticin Java può essere invocata Classname.variablenameo Classname.methodnameo direttamente. Non è obbligatorio invocarlo solo utilizzando il nome dell'oggetto.

Nell'interfaccia, gli oggetti non possono essere dichiarati e staticrende possibile invocare variabili solo attraverso il nome della classe senza la necessità del nome dell'oggetto.

final:

Aiuta a mantenere un valore costante per una variabile in quanto non può essere sovrascritto nelle sue sottoclassi.