Quand convient-il d'utiliser des variables finales vierges?

J'ai été à la recherche à un autre question sur les variables final et a remarqué que vous pouvez déclarer les variables final sans l'initialiser (vide final variable). Est-il une raison pour laquelle il est souhaitable de le faire, et quand est-il avantageux?

source d'informationauteur Rob Volgman

final java

26

C'est utile pour créer des objets immuables:
```
public class Bla {
    private final Color color;

    public Bla(Color c) {this.color = c};

}
```
Bla est immuable (une fois créé, il ne peut pas changer parce que la couleur est définitive).
Mais vous pouvez toujours créer différents Blas par la construction avec les différentes couleurs.

Voir aussi cette question par exemple.

MODIFIER

Peut-être intéressant d'ajouter qu'un "vide final" a un sens très précis en Java, ce qui semble avoir créé une certaine confusion dans les commentaires - cf la Java Langage De Spécification 4.12.4:

Un vide final est une variable finale dont la déclaration n'a pas de initialiseur.

Ensuite, vous devez attribuer à vide dernière variable dans un constructeur.
5

Le final de la propriété de la classe doit avoir une valeur affectée avant d'objet est créé. De sorte que le dernier point où vous pouvez attribuer de la valeur à leur est un constructeur.

Il est utilisé souvent pour des objets immuables.
```
 public class Foo {

  private final Bar bar;

  public Foo(Bar bar) {
    this.bar = bar;
  }

  public Bar getBar() {
   return new Bar(bar);
 } 
}
```
Ce wiki dit à ce sujet

La défensive de la copie.

Vous pouvez le faire lorsque vous n'avez pas connu ce que la valeur sera préalable à l'instrumentation d'un Objet, il faut juste avoir une valeur assignée dans son constructeur.

C'est comment vous faites des objets immuables et il est utilisé dans le générateur de modèle.

class Builder{
    final BuilderContext context;

    private Builder(BuilderContext context){
        this.context=context;
    }       

    public static Builder New(){
        return new Builder(new BuilderContext());
    }

Vide final, les variables doivent être attribuées "quelque part" dans le constructeur. Plutôt construits exemple:

public class Test {
    final int sign;
    public Test(String upDown) {
        if (upDown.equals("up")) {
            sign = +1;
        } else {
            sign = -1;
        }
    }
}

Un cas pourrait être quand vous avez un domaine qui vous voulez déclarer finale, mais dont la cession peut lever une exception, et vous voulez être en mesure de prendre des mesures si cela se passe:

class A {
  final URLConnection conn;
  A(String url) {
    try {
      this.conn = new URL(url).openConnection();
    } catch (IOException | MalformedURLException e) {
      //Maybe this isn't fatal, so just handle the Exception
      //here and move on happily
    }
  }
}

1

Utiliser un vide final de la variable à l'intérieur d'une méthode pour montrer que tous les chemins de code qui utilisent la variable d'affecter cette variable exactement une fois (ou lever une exception). Compilateurs Java permettra de garantir qu'un vide final de la variable est attribuée avant de l'utiliser.

Exemple de code à l'intérieur d'une méthode:
```
  final Foo foo;
  if (condition1()) {
    foo = makeFoo(1);
  } else if (condition2()) {
    throw new BarException();
  } else {
    foo = makeFoo(-1);
  }
  ...
  blahBlahBlah(foo);
```
À l'aide de vide final variables raconte le prochain lecteur de code que le compilateur garantit que quelqu'un affecté foo avant d'appeler blahBlahBlah(foo).

La question demande "vide final variables". Discussion de "vide final champs" est une autre discussion, et intéressant dans son propre droit.
0

De Wikipedia

Le vide final, qui a été introduit dans Java 1.1, une dernière variable dont la déclaration n'a pas de initialiseur. Un vide final ne peut être attribuée qu'une fois et doit être assignée lorsqu'une tâche se produit. Pour ce faire, un compilateur Java exécute une analyse des flux de veiller à ce que, pour chaque affectation à un vide final de la variable, la variable est non attribuées définitivement avant la cession; sinon, une erreur de compilation se produit.

En général, un compilateur Java permettra de s'assurer que le vide final n'est pas utilisé jusqu'à ce qu'il est affecté d'une valeur et que, une fois attribué une valeur, la dernière variable ne peut être réattribué à une autre valeur.
0

remarqué que vous pouvez déclarer final variables sans l'initialiser leur

Vous devez les initialiser plus tard (par exemple dans le constructeur) de sorte qu'il ne restera pas vide.

Je les trouve très utile pour les méthodes qui découlent d'un état. Il fournit un environnement propre chemin d'exécution et permet de s'assurer de la variable d'état est attribué une seule fois. Par exemple:

public boolean isEdible() {
    final boolean edible;

    if (vegetable) {
        edible = true;
    } else if (animal) {
        if (vegetarian) {
            edible = false;
        } else {
            edible = true;
        } 
    }
    System.out.println("Is edible: " + edible);
    return edible;
}

Vous devez vous connecter pour publier un commentaire.