Pourquoi l'objet final peut-il être modifié ?

Question

Je suis tombé sur le code suivant dans une base de code sur laquelle je travaille :

public final class ConfigurationService {
    private static final ConfigurationService INSTANCE = new ConfigurationService();
    private List providers;

    private ConfigurationService() {
        providers = new ArrayList();
    }

    public static void addProvider(ConfigurationProvider provider) {
        INSTANCE.providers.add(provider);
    }

    ...

INSTANCE est déclaré comme final . Pourquoi des objets peuvent-ils être ajoutés à INSTANCE ? Cela ne devrait-il pas invalider l'utilisation de final ? (Ce n'est pas le cas).

Je suppose que la réponse a quelque chose à voir avec les pointeurs et la mémoire, mais j'aimerais en être sûr.

Answer 1

final rend simplement l'objet référence immuable. L'objet vers lequel il pointe n'est pas immuable en faisant cela. INSTANCE ne peut jamais faire référence à un autre objet, mais l'objet auquel il fait référence peut changer d'état.

Answer 2

Être définitif n'est pas la même chose qu'être immuable.

final != immutable

En final est utilisé pour s'assurer que la référence n'est pas modifiée (c'est-à-dire que la référence qu'il possède ne peut pas être remplacée par une nouvelle référence).

Mais, si l'attribut est modifiable, il est possible de faire ce que vous venez de décrire.

Par exemple

class SomeHighLevelClass {
    public final MutableObject someFinalObject = new MutableObject();
}

Si nous instancions cette classe, nous ne pourrons pas attribuer une autre valeur à l'attribut someFinalObject parce que c'est final .

Ce n'est donc pas possible :

....
SomeHighLevelClass someObject = new SomeHighLevelClass();
MutableObject impostor  = new MutableObject();
someObject.someFinal = impostor; // not allowed because someFinal is .. well final

Mais si l'objet lui-même est mutable comme ceci :

class MutableObject {
     private int n = 0;

     public void incrementNumber() {
         n++;
     }
     public String toString(){
         return ""+n;
     }
}  

Ensuite, la valeur contenue dans cet objet mutable peut être modifiée.

SomeHighLevelClass someObject = new SomeHighLevelClass();

someObject.someFinal.incrementNumber();
someObject.someFinal.incrementNumber();
someObject.someFinal.incrementNumber();

System.out.println( someObject.someFinal ); // prints 3

Cela a le même effet que votre poste :

public static void addProvider(ConfigurationProvider provider) {
    INSTANCE.providers.add(provider);
}

Ici, vous ne changez pas la valeur de l'INSTANCE, vous modifiez son état interne (via la méthode providers.add).

si vous voulez empêcher cela, la définition de la classe doit être modifiée comme ceci :

public final class ConfigurationService {
    private static final ConfigurationService INSTANCE = new ConfigurationService();
    private List providers;

    private ConfigurationService() {
        providers = new ArrayList();
    }
    // Avoid modifications      
    //public static void addProvider(ConfigurationProvider provider) {
    //    INSTANCE.providers.add(provider);
    //}
    // No mutators allowed anymore :) 
....

Mais, cela pourrait ne pas avoir beaucoup de sens :)

Au fait, vous devez aussi synchroniser son accès essentiellement pour la même raison.

Answer 3

La clé du malentendu se trouve dans le titre de votre question. Ce n'est pas le objet qui est définitif, c'est le variable . La valeur de la variable ne peut pas changer, mais les données qu'elle contient peuvent changer.

N'oubliez jamais que lorsque vous déclarez une variable de type référence, la valeur de cette variable est une référence, et non un objet.

Answer 4

final signifie simplement que la référence ne peut pas être modifiée. Vous ne pouvez pas réassigner INSTANCE à une autre référence si elle est déclarée comme finale. L'état interne de l'objet est toujours mutable.

final ConfigurationService INSTANCE = new ConfigurationService();
ConfigurationService anotherInstance = new ConfigurationService();
INSTANCE = anotherInstance;

entraînerait une erreur de compilation

Answer 5

Final et immuable ne sont pas la même chose. Final signifie que la référence ne peut pas être réaffectée, vous ne pouvez donc pas dire

INSTANCE = ...

Immuable signifie que l'objet lui-même ne peut pas être modifié. Un exemple de cela est le java.lang.String classe. Vous ne pouvez pas modifier la valeur d'une chaîne de caractères.