Dlaczego można zmodyfikować ostateczny obiekt?

W bazie kodu, nad którą pracuję, natknąłem się na następujący kod:

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);
    }

    ...

INSTANCEjest zadeklarowany jako final. Dlaczego można dodawać obiekty INSTANCE? Nie powinno to unieważniać użycia wersji ostatecznej. (Tak nie jest).

Zakładam, że odpowiedź ma coś wspólnego ze wskaźnikami i pamięcią, ale chciałbym wiedzieć na pewno.

finalpo prostu sprawia, że odniesienie do obiektu jest niezmienne. W ten sposób obiekt, na który wskazuje, nie jest niezmienny. INSTANCEnigdy nie może odnosić się do innego obiektu, ale obiekt, do którego się odnosi, może zmienić stan.

Bycie ostatecznym to nie to samo, co bycie niezmiennym.

final != immutable

Słowo finalkluczowe jest używane, aby upewnić się, że odniesienie nie zostanie zmienione (to znaczy, że odniesienie, które ma, nie może zostać zastąpione nowym)

Ale jeśli atrybut self jest modyfikowalny, możesz zrobić to, co właśnie opisałeś.

Na przykład

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

Jeśli utworzymy instancję tej klasy, nie będziemy mogli przypisać innej wartości do atrybutu, someFinalObjectponieważ tak jest ostateczny .

Więc to nie jest możliwe:

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

Ale jeśli sam obiekt jest zmienny w następujący sposób:

class MutableObject {
     private int n = 0;

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

Następnie wartość zawarta w tym zmiennym obiekcie może zostać zmieniona.

SomeHighLevelClass someObject = new SomeHighLevelClass();

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

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

Ma to taki sam efekt, jak Twój post:

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

Tutaj nie zmieniasz wartości INSTANCE, tylko modyfikujesz jej stan wewnętrzny (metoda, provider.add)

jeśli chcesz zapobiec zmianie definicji klasy w ten sposób:

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 :) 
....

Ale to może nie mieć większego sensu :)

Nawiasem mówiąc, musisz również zsynchronizować dostęp do niego w zasadzie z tego samego powodu.

Klucz do nieporozumienia znajduje się w tytule pytania. To nie obiekt jest ostateczny, to zmienna . Wartość zmiennej nie może się zmienić, ale zawarte w niej dane mogą.

Zawsze pamiętaj, że kiedy deklarujesz zmienną typu referencyjnego, wartość tej zmiennej jest referencją, a nie obiektem.

Final oznacza tylko, że odniesienia nie można zmienić. Nie możesz ponownie przypisać INSTANCE do innego odwołania, jeśli jest ono zadeklarowane jako ostateczne. Stan wewnętrzny obiektu jest nadal zmienny.

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

zgłosiłby błąd kompilacji

Po przypisaniu finalzmiennej zawsze zawiera ona tę samą wartość. Jeśli finalzmienna zawiera odniesienie do obiektu, wówczas stan obiektu może zostać zmieniony przez operacje na obiekcie, ale zmienna będzie zawsze odnosić się do tego samego obiektu. Dotyczy to również tablic, ponieważ tablice są obiektami; jeśli finalzmienna zawiera odniesienie do tablicy, wówczas składniki tablicy mogą zostać zmienione przez operacje na tablicy, ale zmienna będzie zawsze odnosić się do tej samej tablicy.

Źródło

Oto przewodnik, jak uczynić obiekt niezmiennym .

Ostateczne i niezmienne to nie to samo. Ostatnia oznacza, że ​​odniesienia nie można ponownie przypisać, więc nie można tego powiedzieć

INSTANCE = ...

Niezmienny oznacza, że ​​sam obiekt nie może być modyfikowany. Przykładem tego jest java.lang.Stringklasa. Nie możesz modyfikować wartości ciągu.

Java nie ma koncepcji niezmienności wbudowanej w język. Nie ma możliwości oznaczenia metod jako mutatora. Dlatego język nie ma możliwości wymuszenia niezmienności obiektu.