Plaidoyers finals dans les méthodes de l’interface - ce qui ' s le point ?

Question

En Java, il est parfaitement légal de définir final arguments dans les méthodes d'interface et de ne pas obéir que dans la mise en œuvre de la classe, par exemple:

public interface Foo {
    public void foo(int bar, final int baz);
}

public class FooImpl implements Foo {

    @Override
    public void foo(final int bar, int baz) {
        ...
    }
}

Dans l'exemple ci-dessus, bar et baz a l'opposé final définitions dans la classe VS l'interface.

De la même manière, pas de final restrictions sont appliquées lorsqu'une méthode de la classe s'étend à un autre, soit abstract ou pas.

Alors qu' final a une valeur pratique à l'intérieur de la méthode de classe de corps, il y a le point en précisant final pour l'interface des paramètres de la méthode?

Answer 1

Il ne semble pas comme elle. Selon le Java Language Specification 4.12.4:

La déclaration d'une variable final peut servir comme documentation utile que sa valeur ne changera pas et peut aider à éviter les erreurs de programmation.

Cependant, une final modificateur sur un paramètre de méthode n'est pas mentionné dans les règles pour la mise en correspondance des signatures de méthodes de remplacement, et il n'a pas d'effet sur l'appelant, seulement dans le corps d'une mise en œuvre. Aussi, comme l'a noté Robin dans un commentaire, l' final modificateur sur un paramètre de méthode n'a aucun effet sur le byte code. (Ce n'est pas vrai pour d'autres utilisations de l' final.)

Answer 2

Certains IDEs copiera la signature de la méthode abstraite/interface lors de l’insertion d’une méthode d’implémentation dans une classe de void.

Je ne crois pas qu'il fait aucune différence pour le compilateur.

Answer 3

Annotations finales des paramètres de méthode ne sont toujours pertinentes à l’implémentation de la méthode jamais à l’appelant. Il n’y a donc aucune raison réelle pour les utiliser dans les signatures de méthode d’interface. Sauf si vous voulez suivre le même standard de codage cohérent, qui requiert des paramètres de méthode finale, dans toutes les signatures de méthode. Ensuite, il est agréable d’être en mesure de le faire.

Answer 4

Mise à jour: réponse Originale à cette question ci-dessous a été écrit sans vraiment comprendre la question, et, par conséquent, ne pas répondre directement à la question :) Néanmoins, il doit être informatif pour ceux qui cherchent à comprendre l'utilisation générale de l' final mot-clé.

Comme pour la question, je voudrais citer mon propre commentaire du dessous.

Je crois que vous n'êtes pas forcé de mettre en œuvre la finalité d'un argument pour vous laisser libre de décider si elle doit être définitive ou non dans votre propre mise en œuvre.

Mais oui, il semble plutôt étrange que vous pouvez déclarer final dans l'interface, mais non définitif dans la mise en œuvre. Il aurait fait plus de sens que si:

un. final mot-clé n'a pas été autorisé pour l'interface (résumé) arguments de méthode (mais vous pouvez l'utiliser dans la mise en œuvre), ou
b. le fait de déclarer un argument final dans l'interface de l'obligerait à être déclarée final dans la mise en œuvre (mais pas obligatoire pour les non-finale).

---

Je pense à deux raisons pour lesquelles une signature de méthode peut avoir final paramètres: les Haricots et les Objets (en Fait, ils sont tous les deux la même raison, mais légèrement différents contextes.)

Objets:

public static void main(String[] args) {
    StringBuilder cookingPot = new StringBuilder("Water ");
    addVegetables(cookingPot);
    addChicken(cookingPot);
    System.out.println(cookingPot.toString());
    // ^--- OUTPUT IS: Water Carrot Broccoli Chicken ChickenBroth 
    //      We forgot to add cauliflower. It went into the wrong pot.
}

private static void addVegetables(StringBuilder cookingPot) {
    cookingPot.append("Carrot ");
    cookingPot.append("Broccoli ");
    cookingPot = new StringBuilder(cookingPot.toString());
    //   ^--- Assignment allowed...
    cookingPot.append("Cauliflower ");
}

private static void addChicken(final StringBuilder cookingPot) {
    cookingPot.append("Chicken ");
    //cookingPot = new StringBuilder(cookingPot.toString());
    //     ^---- COMPILATION ERROR! It is final.
    cookingPot.append("ChickenBroth ");
}

L' final mot-clé veillé à ce que l'on ne risque pas de créer un nouveau local de cuisine en pot, en montrant une erreur de compilation lorsque nous avons tenté de le faire. Cela a permis de faire le bouillon de poulet est ajouté à notre pot de la cuisine qui l' addChicken méthode de got. Comparez cela à l' addVegetables où nous avons perdu le chou-fleur, car il a ajouté qu'un nouveau local de la cuisson du pot au lieu de l'original pot il a obtenu.

Les haricots: C'est le même concept que les objets (comme illustré ci-dessus). Les haricots sont essentiellement Objects en Java. Cependant, beans (Ejb) sont utilisés dans diverses applications, comme un moyen pratique de stocker et de transmettre autour d'une collection de données connexes. Tout comme l' addVegetables pourrait gâcher le processus de cuisson par la création d'un nouveau pot de la cuisine StringBuilder et de le jeter avec le chou-fleur, il pourrait aussi faire de même avec un pot de la cuisine JavaBean.

Answer 5

Je crois que c’est peut-être un détail superflu, car si elle est définitive ou non est un détail d’implémentation.

(Un peu comme déclarant méthodes/membres dans une interface comme public).