Déclarant objet final en java

Quelqu'un peut-il préciser la signification du code ci-dessous.

class A
{
    int i = 10;

    public void setI(int b)
    {
        i = b;
    }

    public int getI()
    {
        return i;
    }
}

class Test
{    
    public static void main(String args[]) throws Throwable
    { 
        final A ob = new A();
        ob.setI(10);
        System.out.println(ob.getI());
    }
}

L'objet A est déclarée comme final, mais je peux changer la valeur de cet objet est variable d'instance et aussi retrive la valeur mise à jour. Alors, quelles sont la signification de la déclaration d'un objet final.
Je suis conscient sur la déclaration de type de données primitif final, ce qui fait que la variable constante.

OriginalL'auteur RickDavis | 2012-06-29

32

ob ne sera pas en mesure de référencer un autre objet : le mot-clé final.

Il ne peut pas être modifiée. Mais vous pouvez changer son fonctionnement interne (il est mutable, si elle était à l'origine).
Donc cela fonctionne :
```
  final A ob = new A();
  ob.setI(6)
```
mais ce n'est pas le cas :
```
  final A ob = new A();
  ob = new A();
```
Donc, fondamentalement, cela n'autorise pas l'attribution d'une nouvelle instance de l'objet? Quels sont les autres choses comme de dire: Image img = loadImage("img.png");. pourriez-vous alors: img = loadImage("image.png");? ou serait-ce illégal?
qu'en pensez-vous ?

OriginalL'auteur
11

Si vous indiquez toute variable final, cela signifie que vous ne voulez pas la valeur qu'elle contient dans la mémoire à changement. Dans le cas de types primitifs, que la valeur représentée par les variables sont les valeurs réelles. Dans le cas des types d'objet, les valeurs dans la mémoire sont des références à l'objet et non pas des objets réels.

Par exemple, vous avez:
```
final int x = 7;
final Object y = new Object();
```
Vous pouvez penser à des données d'être représentés dans la mémoire de cette façon:
```
+----------+----------+
|  block   |  value   |
+----------+----------+
|  1001    |    7     |
|  1002    |  2110    |
+----------+----------+
```
Pour l'amour de la discussion, nous allons laisser de côté les détails de la façon dont Java gère la mémoire (parce que je ne connais pas trop non plus). Ainsi, dans l'exemple ci-dessus, le bloc 1001 est représenté par la variable x, et 1002 par an. Les deux sont variables final ce qui signifie que les valeurs qu'ils représentent ne peuvent pas être modifiés. Dans le cas de x, c'est 7, qui est la valeur réelle, mais dans le cas de y, 2110 est juste une référence à un autre emplacement de mémoire. Les deux ne peut pas changer mais la raison pour laquelle les variables de type primitif devenir constantes est qu'ils représentent des valeurs réelles. Mais en fait, vous pouvez dire la même chose pour le type d'objet variables seulement que le constantes qu'ils représentent sont des références. Ainsi, le final mot-clé est à peu près cohérent à cet égard.

Donc, avec les variables final, si ce sont des types primitifs, ils seront constamment représenter une quelconque des valeurs que vous définissez. S'ils sont l'objet/types de référence, ils seront constamment point à n'importe quel objet de votre choix (quel que soit l'objet de la mutabilité).

OriginalL'auteur
3

Si un objet est final vous pouvez appeler toutes les méthodes que faire des changements à l'interne comme à l'habitude, mais vous ne pouvez pas réaffecter la référence à point à un autre objet. Essayez de faire ceci:
```
final A ob = new A();
ob = new A();
```
et notez que le code ne compile pas.

Penser à cela comme une référence constante.

OriginalL'auteur
3

Cela signifie que le suivant n'est pas possible:
```
final A ob = new A();
ob = new A(); //This is not possible
```
La variable ob également référence à l'instance de la classe A qui a été attribué la première fois. C'est ce que l' final mot-clé signifie dans ce cas. Cela signifie que vous pouvez modifier les attributs de ob parce que c'est un objet normal comme toute autre instance de A.

OriginalL'auteur
2

Bien, dans le cas de l'objet, la valeur de référence est l'adresse à des objets. La valeur de ob sera l'adresse de l'objet créé par new A();qui sera définitive et vous ne serez pas en mesure de modifier sa valeur. ce qui signifie qu'il, Vous ne pouvez pas affecter un nouvel objet pour cette référence.

Vous ne pouvez pas écrire de cette façon.
```
final A ob = new A();

ob= new A(); //not allowed
```
OriginalL'auteur
1

En java, contrairement à C++, tous les objets sont des pointeurs, donc un final objet peut être modifié, il ne peut tout simplement pas n'importe où de nouveau, qui est, vous ne pouvez pas le mettre sur le côté gauche de l'opérateur d'affectation.

OriginalL'auteur
1

Il ne sera pas constante(finale) des objets en java. Les objets sont créés dans la mémoire du Tas de la zone. et on peut modifier l'objet à tout moment.

Il y a seulement constante(finale) les références en java :- vous ne pouvez pas modifier la référence et de la ré-assigner à n'importe quel autre objet, car elle est constante, et par le biais de la finale de référence se réfère à un seul objet qui est affecté lors de la déclaration.

Donc :
```
 final A objectA = new A();
 objectA.setI(6);  
```
Est valide parce que nous sommes en changeant uniquement le contenu de l'objet, et non pas la référence.

Mais:
```
   final A objectA = new A();
   objectA = new A();  
```
N'est pas valide parce que vous tentez de modifier la référence.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.