Pourquoi tous les champs dans une interface implicitement statique et définitive?

Question

J'essaie simplement de comprendre pourquoi tous les champs définis dans une interface sont static implicitement et final. L'idée de garder les champs static me semble logique que vous ne pouvez pas avoir des objets d'une interface, mais pourquoi ils sont final (implicitement)?

Tout sait pourquoi les concepteurs Java sont allés avec faire les champs dans un static d'interface et final?

Answer 1

Une interface ne peut pas avoir un comportement ou de l'État, car il vise à préciser qu'un contrat d'interaction, pas de détails de mise en œuvre. Aucun comportement est appliquée par un procédé ne permettant pas / corps de constructeur ou des blocs d'initialisation statique / instance. Aucun Etat est appliquée en ne permettant fields.Therefore static final, la classe peut avoir un état (état statique), mais l'état d'instance n'est pas déduit par l'interface.

BTW:. Une constante en Java est définie par un champ final statique (et, par convention, le nom utilise UPPER_CASE_AND_UNDERSCORES)

Answer 2

Raison d'être final

Les implémentations peuvent modifier la valeur des champs si elles ne sont pas définis comme définitive. Ensuite, ils deviendraient une partie de la mise en œuvre. Une interface est une spécification pur, sans aucune mise en œuvre.

Raison d'être static

Si elles sont statiques, ils appartiennent à l'interface, et non l'objet, ni le type de l'objet d'exécution.

Answer 3

Il y a quelques points passés sous silence ici:

Tout simplement parce que les champs dans une interface sont implicitement static final ne signifie pas qu'ils doivent être des constantes de compilation, ou même immuable. Vous pouvez définir par exemple.

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

(Attention que faire cela à l'intérieur d'une définition d'annotation peut confondre javac, relative au fait que ce qui précède en fait une compile initialiseur statique.)

En outre, la raison de cette restriction est plus stylistique que technique, et beaucoup de gens comme pour le voir être détendu .

Answer 4

Les champs doivent être statiques, car ils ne peuvent pas être abstraite (comme les méthodes peuvent). Parce qu'ils ne peuvent pas être abstraite, les réalisateurs ne seront pas en mesure de fournir logiquement la mise en œuvre des différents champs.

Les champs doivent être finale, je pense, parce que les champs sont accessibles par de nombreux permet-ils implémenteurs être variable pourrait être problématique (comme la synchronisation). Aussi éviter d'être mis en œuvre à nouveau (caché).

Juste ma pensée.

Answer 5

Je considère l'exigence que les champs soient finale trop restrictive et une erreur par les concepteurs du langage Java. Il y a des moments, par exemple la manipulation des arbres, lorsque vous devez définir des constantes dans la mise en œuvre qui sont nécessaires pour effectuer des opérations sur un objet du type d'interface. La sélection d'un chemin de code sur la classe d'implémentation est une bidouille. La solution que je l'utilise est de définir une fonction d'interface et la mettre en œuvre en retournant un littéral:

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";
    }
    ...
}

Cependant, il serait plus simple, plus claire et moins sujettes à la mise en œuvre aberrant d'utiliser cette syntaxe:

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";
    ...
}

Answer 6

Spécification, contrats ... L'instruction de la machine pour accéder aux champs utilise l'adresse de l'objet plus champ de décalage. Les classes peuvent implémenter plusieurs interfaces, il n'y a pas moyen de faire champ d'interface non-finale d'avoir le même décalage dans toutes les classes qui étendent cette interface. Par conséquent mécanisme différent pour l'accès au champ doit être mis en oeuvre: deux accès mémoire (champ de décalage obtenir, obtenir la valeur de champ) au lieu d'un plus le maintien de type de table de zones virtuelles (analogue de table de méthode virtuelle). Je suppose qu'ils ne voulaient pas compliquer Jvm fonctionnalité qui peut être facilement simulée par trucs existants (méthodes).

Dans scala nous pouvons avoir des champs dans les interfaces, si elles sont mises en œuvre en interne comme je l'ai expliqué plus haut (comme méthodes).

Answer 7

static :

Anything (variable ou méthode) qui est static en Java peut être invoqué comme Classname.variablename ou Classname.methodname ou directement. Il n'est pas obligatoire de l'invoquer uniquement en utilisant le nom de l'objet.

Dans l'interface, les objets ne peuvent être déclarés et static permet d'invoquer des variables seulement par nom de classe sans avoir besoin de nom d'objet.

final :

Il aide à maintenir une valeur constante pour une variable car il ne peut pas être redéfinie dans ses sous-classes.