Jak działa "ostateczne" słowo kluczowe w Javie? (Nadal mogę modyfikować obiekt.)

To jest ulubione pytanie z wywiadu . Z tymi pytaniami ankieter próbuje dowiedzieć się, jak dobrze rozumiesz zachowanie obiektów w odniesieniu do konstruktorów, metod, zmiennych klas (zmiennych statycznych) i zmiennych instancji.

import java.util.ArrayList;
import java.util.List;

class Test {
    private final List foo;

    public Test() {
        foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

    public void setFoo(List foo) {
       //this.foo = foo; Results in compile time error.
    }
}

W powyższym przypadku zdefiniowaliśmy konstruktor dla 'Test' i nadaliśmy mu metodę 'setFoo'.

O konstruktorze: konstruktor może być wywołany tylko jeden Czas na obiekt tworzenie za pomocą słowa kluczowego new. Nie można wywoływać konstruktora wiele razy, ponieważ konstruktory nie są do tego zaprojektowane.

O metodzie: metoda może być wywoływana tyle razy, ile chcesz (nawet nigdy) i kompilator o tym wie.

Scenariusz 1

private final List foo;  // 1

foo jest zmienną instancją . Kiedy tworzymy obiekt klasy Test wtedy zmienna instancji foo zostanie skopiowana wewnątrz obiektu klasy Test. Jeśli przypisujemy foo wewnątrz konstruktora, wtedy kompilator wie, że konstruktor zostanie wywołany tylko raz, więc nie ma problemu z przypisaniem go wewnątrz konstruktora.

Jeśli przypisamy foo wewnątrz metody, kompilator wie, że metodę można wywołać wiele razy, co oznacza, że wartość będzie musiała być zmieniana wiele razy, co nie jest dozwolone dla zmiennej final. Więc kompilator decyduje konstruktor jest dobrym wyborem! możesz przypisać wartość tylko do zmiennej końcowej jeden raz.

Scenariusz 2

private static final List foo = new ArrayList();

foo jest teraz zmienną statyczną . Kiedy tworzymy instancję klasy Test, foo nie zostanie skopiowana do obiektu, ponieważ foo jest statyczna. Teraz {[5] } nie jest niezależną własnością każdego obiektu. Jest to Właściwość klasy Test. Ale foo można zobaczyć przez wiele obiektów i jeśli każdy obiekt, który jest tworzony za pomocą słowa kluczowego new, który ostatecznie wywoła konstruktor Test, który zmienia wartość w czas utworzenia wielu obiektów (Remember static foo nie jest kopiowany w każdym obiekcie, ale jest współdzielony między wieloma obiektami.)

Scenariusz 3

t.foo.add("bar"); // Modification-2

Powyżej {[22] } pochodzi z twojego pytania. W powyższym przypadku nie zmieniasz pierwszego obiektu odniesienia, ale dodajesz zawartość wewnątrz foo, co jest dozwolone. Kompilator skarży się, jeśli spróbujesz przypisać new ArrayList() do zmiennej referencyjnej foo.
reguła Jeśli zainicjowałeś final zmiennej, wtedy nie można jej zmienić, aby odnosiła się do innego obiektu. (W tym przypadku ArrayList)

Klasy końcowe nie mogą być podklasowane
ostateczne metody nie mogą zostać nadpisane. (Ta metoda jest w superklasie)
końcowe metody mogą nadpisać. (Przeczytaj to w sposób gramatyczny. Ta metoda jest w podklasie)

końcowe Słowo kluczowe ma wiele sposobów użycia:

• ostateczna klasa nie może być podklasowana.
• a final method cannot be overridden by subclasses
• końcowa zmienna może być zainicjalizowana tylko raz

Inne użycie:

• gdy w ciele metody zdefiniowana jest anonimowa Klasa wewnętrzna, wszystkie zmienne zadeklarowane jako ostateczne w zakresie tej metody są dostępne od wewnątrz class

Statyczna zmienna klasy będzie istnieć od początku JVM i powinna być zainicjalizowana w klasie. Komunikat o błędzie nie pojawi się, jeśli to zrobisz.

Słowo kluczowe final może być interpretowane na dwa różne sposoby w zależności od tego, na czym jest używane:

Typy wartości: dla int s, double S itd, zapewni to, że wartość nie może się zmienić,

Typy odniesień: W przypadku odniesień do obiektów, final zapewnia, że odniesienie Nigdy się nie zmieni, co oznacza, że zawsze będzie odnosiło się do tego samego obiektu. Nie daje żadnych gwarancji co do wartości wewnątrz przedmiotu, o którym mowa, pozostając to samo.

Jako takie, final List<Whatever> foo; zapewnia, że foo zawsze odnosi się do tej samej listy, ale zawartość wspomnianej listy może ulec zmianie w czasie.

Jeśli tworzysz foo statyczną, musisz zainicjować ją w konstruktorze klasy (lub inline, gdzie ją definiujesz), jak w poniższych przykładach.

Konstruktor klasy (nie instancja):

private static final List foo;

static
{
   foo = new ArrayList();
}

Inline:

private static final List foo = new ArrayList();

Problem nie polega na tym, jak działa modyfikator final, ale raczej jak działa modyfikator static.

Modyfikator final wymusza inicjalizację referencji do czasu zakończenia wywołania konstruktora (tj. musi go zainicjować w konstruktorze).

Kiedy inicjalizujesz atrybut in-line, jest on inicjalizowany przed uruchomieniem kodu zdefiniowanego dla konstruktora, więc otrzymujesz następujące rezultaty:

• jeśli foo jest static, foo = new ArrayList() zostanie wykonane przed wykonaniem static{} konstruktora zdefiniowanego dla twojej klasy
• jeśli foo nie jest static, foo = new ArrayList() zostanie wykonane przed uruchomieniem twojego konstruktora

Gdy nie inicjalizujesz atrybutu in-line, modyfikator final wymusza, że zainicjalizujesz go i że musisz to zrobić w konstruktorze. Jeśli masz również modyfikator static, konstruktor, w którym będziesz musiał zainicjować atrybut, to blok inicjalizacji klasy : static{}.

Błąd, który pojawia się w kodzie, wynika z faktu, że static{} jest uruchamiany podczas ładowania klasy, zanim utworzysz instancję obiektu tej klasy. Tak więc, nie będziesz miał inicjalizacji foo podczas tworzenia klasy.

Pomyśl o blok static{} jako konstruktor dla obiektu typu Class. W tym miejscu należy zainicjalizować atrybuty klasy static final (jeśli nie są wykonywane w linii).

Uwaga boczna:

Modyfikator final zapewnia const-ness tylko dla typów prymitywnych i odniesień.

Kiedy deklarujesz obiekt final, otrzymujesz final odniesienie do tego obiektu, ale sam obiekt nie jest stały.

Co naprawdę osiągasz deklarując final atrybutem jest to, że po zadeklarowaniu obiektu do określonego celu (jak final List, który zadeklarowałeś), tylko ten obiekt będzie używany do tego celu: nie będziesz mógł zmienić List foo na inny List, ale nadal możesz zmienić List dodając/usuwając elementy (List, którego używasz, będzie taki sam, tylko ze zmienioną zawartością).

To bardzo dobre pytanie. Czasami mogą nawet zapytać, jaka jest różnica między ostatecznym i niezmiennym obiektem.

1) gdy ktoś wspomina o ostatecznym obiekcie, oznacza to, że Referencja nie może zostać zmieniona, ale jej stan (zmienne instancji) może zostać zmieniony.

2) obiekt niezmienny to taki, którego stan możenie zostać zmieniony, ale jego odniesienie może zostać zmienione. Ex:

    String x = new String("abc"); 
    x = "BCG";

Zmienna Ref X może być zmieniona na inny ciąg znaków, ale wartość " abc " nie może zostać zmieniona.

3) zmienne instancji (niestatyczne pola) są inicjowane podczas wywoływania konstruktora. Możesz więc inicjalizować wartości do zmiennych wewnątrz konstruktora.

4) "ale widzę, że można zmienić wartość w konstruktorze / metodach klasy". -- Nie można tego zmienić wewnątrz metody.

5) zmienna statyczna jest inicjalizowana podczas ładowania klasy. Więc nie można zainicjować wewnątrz konstruktora, to musi być zrobione nawet przed nim. Więc musisz przypisać wartości do zmiennej statycznej podczas samej deklaracji.

Warto wymienić kilka prostych definicji:

Klasy / Metody

Możesz zadeklarować niektóre lub wszystkie metody klasy jako final, aby wskazać, że metoda nie może być nadpisana przez podklasy.

Zmienne

Po zainicjowaniu zmiennej final zawsze zawiera tę samą wartość.

final zasadniczo unikaj nadpisywania / superscribe przez cokolwiek (podklasy, zmienna " resign"), w zależności od sprawy.

Przypuśćmy, że masz dwa pudełka na pieniądze, czerwone i białe. Przypisujesz te moneyboxes tylko dwoje dzieci i nie mogą wymieniać swoich skrzynek. Więc masz czerwone lub białe moneyboxes (ostateczne) nie można modyfikować pole, ale można umieścić pieniądze na polu.Nobody cares (modyfikacja-2).

final jest zarezerwowanym słowem kluczowym w Javie, które ogranicza użytkownika i może być stosowane do zmiennych członkowskich, metod, klas i zmiennych lokalnych. Zmienne końcowe są często deklarowane za pomocą static słowa kluczowe w Javie i są traktowane jako stałe. Na przykład:

public static final String hello = "Hello";

Kiedy używamy final słowo kluczowe z deklaracją zmiennej, wartość przechowywana wewnątrz tej zmiennej nie może być zmieniona.

Na przykład:

public class ClassDemo {
  private final int var1 = 3;
  public ClassDemo() {
    ...
  }
}

Uwaga : Klasa A zadeklarowana jako ostateczna nie może być rozszerzona ani dziedziczona(tzn. nie może istnieć podklasa klasy super). Warto również zauważyć, że metody zadeklarowane jako końcowe nie mogą być nadpisywane przez podklasy.

Korzyści płynące z użycia ostatniego słowa kluczowego są omówione w ten wątek .

Słowo kluczowe final w języku java jest używane do ograniczania użytkownika. Słowo kluczowe java final może być używane w wielu kontekstach. Finał może być:

1. zmienna
2. metoda
3. Klasa

Słowo kluczowe final może być stosowane ze zmiennymi, zmienna final, która nie ma wartości, nazywana jest zmienną pustą final lub zmienną niezainicjalizowaną final. Można go zainicjować tylko w konstruktorze. Pustą zmienną final może być również static, która zostanie zainicjowana w static tylko blok.

Java final variable:

Jeśli ustawisz dowolną zmienną jako final, to nie możesz zmienić wartości zmiennej final (będzie stała).

Przykład zmiennej final

Istnieje ostateczna zmienna speedlimit, zamierzamy zmienić wartość tej zmiennej, ale nie można jej zmienić, ponieważ ostateczna zmienna raz przypisana wartość Nigdy nie może być zmieniona.

class Bike9{  
    final int speedlimit=90;//final variable  
    void run(){  
        speedlimit=400;  // this will make error
    }  

    public static void main(String args[]){  
    Bike9 obj=new  Bike9();  
    obj.run();  
    }  
}//end of class  

Java final class:

Jeśli niech każda klasa będzie final, ty nie możesz jej rozszerzyć .

Przykład klasy końcowej

final class Bike{}  

class Honda1 extends Bike{    //cannot inherit from final Bike,this will make error
  void run(){
      System.out.println("running safely with 100kmph");
   }  

  public static void main(String args[]){  
      Honda1 honda= new Honda();  
      honda.run();  
      }  
  }  

Java final method:

Jeśli uczynisz dowolną metodę ostateczną, nie możesz jej zastąpić.

Przykład metody final w Hondzie nie można zastąpić run () w motocyklu)

class Bike{  
  final void run(){System.out.println("running");}  
}  

class Honda extends Bike{  
   void run(){System.out.println("running safely with 100kmph");}  

   public static void main(String args[]){  
   Honda honda= new Honda();  
   honda.run();  
   }  
}  

Udostępniony z: http://www.javatpoint.com/final-keyword

Kiedy statyczny jest ostateczny, powinien zostać zainicjowany w statycznym bloku inicjalizacji

    private static final List foo;

    static {
        foo = new ArrayList();
    }

    public Test()
    {
//      foo = new ArrayList();
        foo.add("foo"); // Modification-1
    }

Słowo kluczowe final wskazuje, że zmienna może zostać zainicjowana tylko raz. W kodzie wykonujesz tylko jedną inicjalizację finalnego, więc warunki są spełnione. Ta instrukcja wykonuje samotną inicjalizację foo. Zauważ, że final != niezmienny, oznacza to tylko, że odniesienie nie może się zmienić.

foo = new ArrayList();

Kiedy zadeklarujesz foo jako static final zmienna musi być zainicjalizowana podczas ładowania klasy i nie może polegać na instancjacji (aka wywołaniu konstruktora), aby zainicjować foo ponieważ statyczne pola muszą być dostępne bez instancji klasy. Nie ma gwarancji, że konstruktor zostanie wywołany przed użyciem pola statycznego.

Podczas wykonywania metody w scenariuszu static final klasa Test jest ładowana przed utworzeniem instancji t w tym czasie nie ma instancji foo, co oznacza, że nie została zainicjowana, więc foo jest ustawiona na domyślną dla wszystkich obiektów, którą jest null. W tym momencie zakładam, że Twój kod rzuca NullPointerException podczas próby dodania elementu do listy.

1. ponieważ końcowa zmienna jest niestatyczna, może być zainicjalizowana w konstruktorze. Ale jeśli uczynisz go statycznym, nie może być zainicjowany przez konstruktor (ponieważ konstruktory nie są statyczne).
2. Dodawanie do listy nie powinno się zakończyć, czyniąc listę ostateczną. final po prostu wiąże odniesienie do konkretnego obiektu. Możesz dowolnie zmieniać "stan" tego obiektu, ale nie samego obiektu.

Przeczytaj wszystkie odpowiedzi.

Istnieje inny przypadek użytkownika, w którym słowo kluczowe final może być użyte np. w argumencie metody:

public void showCaseFinalArgumentVariable(final int someFinalInt){

   someFinalInt = 9; // won't compile as the argument is final

}

Można użyć dla zmiennej, która nie powinna być zmieniana.

Pomyślałem o napisaniu zaktualizowanej i dogłębnej odpowiedzi tutaj.

final słowo kluczowe może być używane w kilku miejscach.

1. klasy

A final class oznacza, że Nie. inna klasa może extend ostatnie zajęcia. Kiedy Czas Uruchamiania Javy (JRE) wie, że odniesienie do obiektu jest w typie klasy końcowej (powiedzmy F), wie, że wartość tego odniesienia może być tylko w typie F.

Ex:

F myF;
myF = new F();    //ok
myF = someOther;  //someOther cannot be in type of a child class of F.
                  //because F cannot be extended.

Więc gdy wykonuje dowolną metodę tego obiektu, ta metoda nie potrzebuje do rozwiązania w czasie wykonywania przy użyciu wirtualny stół. nie można zastosować polimorfizmu czasowego. Więc czas biegu nie przeszkadza o to. Co oznacza, że oszczędza czas przetwarzania, co poprawi wydajność.

1. metody

A final method dowolnej klasy oznacza, że każda klasa potomna rozszerzająca tę klasę nie można nadpisać że metoda (- y) końcowa (- e). Tak więc zachowanie czasu pracy w tym scenariuszu jest również takie samo jak poprzednie zachowanie, o którym wspomniałem dla klas.

1. pola, zmienne lokalne, parametry metody

Jeśli ktoś poda dowolny z powyższych jako final, oznacza to, że wartość jest już skończona, więc wartość nie może zostać zmieniona.

Ex:

Dla pól, parametry lokalne

final FinalClass fc = someFC; //need to assign straight away. otherwise compile error.
final FinalClass fc; //compile error, need assignment (initialization inside a constructor Ok, constructor can be called only once)
final FinalClass fc = new FinalClass(); //ok
fc = someOtherFC; //compile error
fc.someMethod(); //no problem
someOtherFC.someMethod(); //no problem

Dla parametrów metody

void someMethod(final String s){
    s = someOtherString; //compile error
}

To po prostu oznacza, że nie można zmienić wartości referencyjnej final. tzn. dozwolona jest tylko jedna inicjalizacja. W tym scenariuszu, w czasie wykonywania, od JRE wie, że wartości nie można zmienić, ładuje wszystkie te zakończone wartości (końcowych odniesień) do L1 cache. Ponieważ to nie potrzebuje na załaduj z powrotem znowu i znowu od pamięć główna. W przeciwnym razie ładuje się do pamięci podręcznej L2 i ładuje od czasu do czasu z pamięci głównej. Jest to więc również poprawa wydajności.

Więc we wszystkich powyższych 3 scenariuszach, gdy nie podaliśmy słowa kluczowego final w miejscach, których możemy użyć, nie musimy się martwić, optymalizacje kompilatorów zrobią to za nas. Istnieje również wiele innych rzeczy, które optymalizacje kompilatorów zrobić dla nas. :)

Przede wszystkim są poprawne. Ponadto, jeśli nie chcesz, aby inni tworzyli podklasy z twojej klasy, zadeklaruj klasę jako ostateczną. Wtedy staje się poziom liścia hierarchii drzewa klas, że nikt nie może go dalej rozszerzyć. Dobrą praktyką jest unikanie ogromnej hierarchii klas.

Po pierwsze, miejsce w kodzie, w którym inicjujesz (tzn. przypisujesz po raz pierwszy) foo jest tutaj:

foo = new ArrayList();

Foo jest obiektem (z listą typów), więc jest to typ referencji, a nie Typ wartości (jak int). 0xa7d2a834), gdzie przechowywane są elementy listy. Linie takie jak to

foo.add("foo"); // Modification-1

Nie zmieniaj wartości foo(co, znowu, jest tylko odniesieniem do lokalizacji pamięci). Zamiast tego po prostu dodawanie elementów do wskazanej lokalizacji pamięci. Aby naruszyć słowo kluczowe final, musisz spróbować ponownie przypisać foo w następujący sposób:

foo = new ArrayList();

Tospowodowałoby błąd kompilacji.

Teraz, mając to na uwadze, zastanów się, co się stanie, gdy dodasz słowo kluczowe static .

Jeśli nie masz statycznego słowa kluczowego, każdy obiekt, który tworzy instancję klasy, ma własną kopię foo. Dlatego konstruktor przypisuje wartość do pusta, świeża Kopia zmiennej foo, która jest w porządku.

Jednakże, gdy masz słowo kluczowe statyczne, w pamięci istnieje tylko jedno foo, które jest powiązane z klasą. Jeśli tworzysz dwa lub więcej obiektów, konstruktor będzie próbował ponownie przypisać ten jeden foo za każdym razem, naruszając słowo kluczowe final.

Poniżej przedstawiono różne konteksty, w których używany jest final.

Zmienne końcowe zmienna końcowa może być przypisana tylko raz. Jeśli zmienna jest referencją, oznacza to, że zmienna nie może być ponownie powiązana z innym obiektem.

class Main {
   public static void main(String args[]){
      final int i = 20;
      i = 30; //Compiler Error:cannot assign a value to final variable i twice
   }
}

Zmienną końcową można przypisać wartość później (nie jest obowiązkowe przypisanie wartości po zadeklarowaniu), ale tylko raz.

Klasy końcowe klasy końcowe nie mogą być rozszerzone (dziedziczone)

final class Base { }
class Derived extends Base { } //Compiler Error:cannot inherit from final Base

public class Main {
   public static void main(String args[]) {
   }
}

Finał metody ostateczna metoda nie może być nadpisana przez podklasy.

//Error in following program as we are trying to override a final method.
class Base {
  public final void show() {
       System.out.println("Base::show() called");
    }
}     
class Derived extends Base {
    public void show() {  //Compiler Error: show() in Derived cannot override
       System.out.println("Derived::show() called");
    }
}     
public class Main {
    public static void main(String[] args) {
        Base b = new Derived();;
        b.show();
    }
}