Est-ce seulement pour la lisibilité que les variables de l'objet immuable sont définies comme finales?

Question

Dans les objets immuables rendant les variables privées limiteront l'accès du monde externe. Quel est le besoin de rendre les variables finales? Est-ce que la raison est seulement de le rendre lisible? que si les variables sont définitives cela signifie que l'objet est immuable? Y a-t-il une raison théorique derrière cela?

Answer 1

Vous ne marquez pas la variable comme finale, mais comme une référence à une variable. Cela ne garantit pas du tout l'immuabilité. Il garantit simplement qu'une fois la référence finale assignée ne peut pas être réaffectée + vous donne la garantie de sécurité du fil.

Prenons un exemple comme celui-ci:

class A { 
private int someVariable = 5; 

public void setSomeVariable(int someVariable) { 
this.someVariable = someVariable; 
} 

class B { 
private final A a; 

public B(A a) { 
    this.a = a; 
} 
} 

public class C { 
public static void main(String[] args) { 
    A someA = new A(); 
    B someB = new B(someA); 

    //field a in B is final but I can do this: 
    someA.setSomeVariable(6); // by having a reference to someA I have modified someB though it is a final field 



} 

Answer 2

Vous semblez avoir quelques idées fausses dans votre compréhension. Allons-y un par un.

si les variables sont finales cela signifie que l'objet est immuable

Ce n'est pas juste. Immuabilité et marquage quelque chose comme final sont des concepts complètement différents.

L'invariabilité rend les propriétés (champs) d'un objet immuables une fois l'objet créé. D'autre part, les variables final sont quelque chose que vous ne pouvez pas changer après la première affectation.

Considérons cette classe d'objet immuable:

class MyClass { 
    private int myField; 
    public int getMyField() { return myField; } 

    public MyClass(int myField) { this.myField = myField; } 
} 

Comme vous pouvez le voir, myField ne peut pas changer à l'initialisation. Il ne peut être modifié dans aucune partie du code sauf le constructeur. Créons une variable de ce:

MyClass obj = new MyClass(10); 

Comme nous le savons, obj.myField ne peut plus être modifié à ce stade, mais peut être changé obj? Oui, il peut, par exemple,

obj = null; 

Vous pouvez déclarer final pour faire obj inchangeable:

final MyClass obj = null; 
obj = new MyClass(10); // error! 

Maintenant que vous voyez la différence entre finale et immuabilité, nous allons passer aux avantages des deux.

L'immunité et final ont à peu près les mêmes avantages. Ils garantissent tous deux que les valeurs qui devraient rester les mêmes ne seront pas modifiées accidentellement. C'est plus "éviter les erreurs" que "améliorer la lisibilité".