Come funziona la parola chiave "finale" in Java? (Posso ancora modificare un oggetto.)

In Java utilizziamo finalparole chiave con variabili per specificare che i suoi valori non devono essere modificati. Ma vedo che puoi cambiare il valore nel costruttore / metodi della classe. Ancora una volta, se la variabile è staticallora è un errore di compilazione.

Ecco il codice:

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 static void main(String[] args) 
  {
      Test t = new Test();
      t.foo.add("bar"); // Modification-2
      System.out.println("print - " + t.foo);
  }
}

Il codice sopra funziona bene e senza errori.

Ora cambia la variabile come static:

private static final List foo;

Ora è un errore di compilazione. Come funziona finaldavvero?

Puoi sempre inizializzare una finalvariabile. Il compilatore si assicura che tu possa farlo una sola volta.

Si noti che i metodi di chiamata su un oggetto archiviato in una finalvariabile non hanno nulla a che fare con la semantica di final. In altre parole: finalriguarda solo il riferimento stesso e non il contenuto dell'oggetto referenziato.

Java non ha il concetto di immutabilità dell'oggetto; ciò si ottiene progettando attentamente l'oggetto ed è uno sforzo tutt'altro che banale.

Questa è una domanda di intervista preferita . Con queste domande, l'intervistatore cerca di capire quanto bene capisci il comportamento degli oggetti rispetto a costruttori, metodi, variabili di classe (variabili statiche) e variabili di istanza.

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.
    }
}

Nel caso sopra, abbiamo definito un costruttore per 'Test' e gli abbiamo dato un metodo 'setFoo'.

Informazioni sul costruttore: il costruttore può essere richiamato una sola volta per creazione di oggetti utilizzando la newparola chiave. Non è possibile richiamare più volte il costruttore, poiché il costruttore non è progettato per farlo.

Informazioni sul metodo: un metodo può essere invocato tutte le volte che vuoi (anche mai) e il compilatore lo sa.

scenario 1

private final List foo;  // 1

fooè una variabile di istanza . Quando creiamo un Testoggetto di classe, la variabile di istanza fooverrà copiata all'interno dell'oggetto di Testclasse. Se assegniamo fooall'interno del costruttore, il compilatore sa che il costruttore verrà invocato solo una volta, quindi non c'è alcun problema ad assegnarlo all'interno del costruttore.

Se assegniamo fooall'interno di un metodo, il compilatore sa che un metodo può essere chiamato più volte, il che significa che il valore dovrà essere modificato più volte, il che non è consentito per una finalvariabile. Quindi il compilatore decide che il costruttore è una buona scelta! È possibile assegnare un valore a una variabile finale solo una volta.

Scenario 2

private static final List foo = new ArrayList();

fooè ora una variabile statica . Quando creiamo un'istanza di Testclasse, foonon verranno copiati sull'oggetto perché fooè statico. Ora foonon è una proprietà indipendente di ogni oggetto. Questa è una proprietà di Testclasse. Ma foopuò essere visto da più oggetti e se ogni oggetto che viene creato utilizzando la newparola chiave che alla fine invocherà il Testcostruttore che modifica il valore al momento della creazione di più oggetti (Ricorda static foonon viene copiato in ogni oggetto, ma è condiviso tra più oggetti .)

Scenario 3

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

Sopra Modification-2è dalla tua domanda. Nel caso precedente, non si sta modificando il primo oggetto referenziato, ma si sta aggiungendo contenuto all'interno del fooquale è consentito. Il compilatore si lamenta se si tenta di assegnare un new ArrayList()alla foovariabile di riferimento.
Regola Se è stata inizializzata una finalvariabile, non è possibile modificarla per fare riferimento a un oggetto diverso. (In questo caso ArrayList)

le classi finali non possono essere sottoclassate i metodi
finali non possono essere sovrascritti. (Questo metodo è in superclasse) i metodi
finali possono sovrascrivere. (Leggi questo in modo grammaticale. Questo metodo è in una sottoclasse)

La parola chiave finale ha molti modi di usare:

• Una classe finale non può essere sottoclassata.
• Un metodo finale non può essere sovrascritto da sottoclassi
• Una variabile finale può essere inizializzata solo una volta

Altro utilizzo:

• Quando una classe interna anonima viene definita nel corpo di un metodo, tutte le variabili dichiarate finali nell'ambito di quel metodo sono accessibili dall'interno della classe interna

Una variabile di classe statica esisterà dall'inizio della JVM e dovrebbe essere inizializzata nella classe. Il messaggio di errore non verrà visualizzato se si esegue questa operazione.

La finalparola chiave può essere interpretata in due modi diversi a seconda dell'utilizzo:

Tipi di valore: per ints, doubles ecc., Assicurerà che il valore non possa cambiare,

Tipi di riferimento: per i riferimenti agli oggetti, finalgarantisce che il riferimento non cambierà mai, il che significa che farà sempre riferimento allo stesso oggetto. Non fornisce alcuna garanzia circa i valori all'interno dell'oggetto a cui si fa riferimento per rimanere gli stessi.

In quanto tale, final List<Whatever> foo;garantisce che foosi riferisca sempre allo stesso elenco, ma i contenuti di tale elenco potrebbero cambiare nel tempo.

Se rendi foostatico, devi inizializzarlo nel costruttore della classe (o inline nel punto in cui lo definisci) come negli esempi seguenti.

Costruttore di classe (non istanza):

private static final List foo;

static
{
   foo = new ArrayList();
}

In linea:

private static final List foo = new ArrayList();

Il problema qui non è come funziona il finalmodificatore, ma piuttosto come funziona il staticmodificatore.

Il finalmodificatore applica un'inizializzazione del riferimento al termine della chiamata al costruttore (ovvero è necessario inizializzarlo nel costruttore).

Quando si inizializza un attributo in linea, questo viene inizializzato prima dell'esecuzione del codice definito per il costruttore, in modo da ottenere i seguenti risultati:

• se fooè static, foo = new ArrayList()verrà eseguito prima che il static{}costruttore è stato definito per la classe viene eseguita
• in caso foocontrario static, foo = new ArrayList()verrà eseguito prima dell'esecuzione del costruttore

Quando non si inizializza un attributo in linea, il finalmodificatore impone di inizializzarlo e che è necessario farlo nel costruttore. Se anche voi avete un staticmodificatore, il costruttore si dovrà inizializzare l'attributo è il blocco di inizializzazione di classe: static{}.

L'errore che si ottiene nel codice deriva dal fatto che static{}viene eseguito quando la classe viene caricata, prima del momento in cui si crea un'istanza di un oggetto di quella classe. Pertanto, non sarà stato inizializzato fooquando viene creata la classe.

Pensa al static{}blocco come a un costruttore per un oggetto di tipo Class. Qui è dove è necessario eseguire l'inizializzazione degli static finalattributi della classe (se non in linea).

Nota a margine:

Il finalmodificatore assicura costanza solo per tipi e riferimenti primitivi.

Quando dichiari un finaloggetto, quello che ottieni è un final riferimento a quell'oggetto, ma l'oggetto stesso non è costante.

Quello che stai veramente ottenendo quando dichiari un finalattributo è che, una volta dichiarato un oggetto per il tuo scopo specifico (come quello final Listche hai dichiarato), quello e solo quell'oggetto sarà usato per quello scopo: non sarai in grado di passare List fooa un altro List, ma puoi comunque modificare il tuo Listaggiungendo / rimuovendo elementi (quello Listche stai usando sarà lo stesso, solo con il suo contenuto modificato).

Questa è un'ottima domanda per l'intervista. A volte potrebbero anche chiederti qual è la differenza tra un oggetto finale e un oggetto immutabile.

1) Quando qualcuno menziona un oggetto finale, significa che il riferimento non può essere modificato, ma il suo stato (variabili di istanza) può essere modificato.

2) Un oggetto immutabile è uno il cui stato non può essere modificato, ma il suo riferimento può essere modificato. Ex:

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

La variabile ref x può essere modificata per indicare una stringa diversa, ma il valore di "abc" non può essere modificato.

3) Le variabili di istanza (campi non statici) vengono inizializzate quando viene chiamato un costruttore. Quindi è possibile inizializzare i valori per le variabili all'interno di un costruttore.

4) "Ma vedo che puoi cambiare il valore nel costruttore / metodi della classe". - Non puoi cambiarlo all'interno di un metodo.

5) Una variabile statica viene inizializzata durante il caricamento della classe. Quindi non è possibile inizializzare all'interno di un costruttore, deve essere fatto anche prima di esso. Quindi è necessario assegnare valori a una variabile statica durante la dichiarazione stessa.

La finalparola chiave in Java viene utilizzata per limitare l'utente. La finalparola chiave java può essere utilizzata in molti contesti. La finale può essere:

1. variabile
2. metodo
3. classe

La finalparola chiave può essere applicata con le variabili, una finalvariabile che non ha valore, è chiamata finalvariabile vuota o finalvariabile non inizializzata . Può essere inizializzato solo nel costruttore. finalPuò staticanche essere la variabile vuota che verrà inizializzata solo nel staticblocco.

Variabile finale Java:

Se si effettua una variabile come final, non è possibile modificare il valore della finalvariabile (sarà costante).

Esempio di finalvariabile

Esiste un limite di velocità della variabile finale, cambieremo il valore di questa variabile, ma non può essere modificato perché una volta che la variabile finale è stata assegnata, un valore non può mai essere modificato.

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  

Classe finale Java:

Se crei una classe come final, non puoi estenderla .

Esempio di classe finale

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

Metodo finale Java:

Se si effettua un metodo come finale, non è possibile sovrascriverlo .

Esempio di finalmetodo (run () in Honda non può ignorare run () in Bike)

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

condiviso da: http://www.javatpoint.com/final-keyword

Vale la pena menzionare alcune definizioni semplici:

Classi / Metodi

È possibile dichiarare alcuni o tutti i metodi di una classe come final, al fine di indicare che il metodo non può essere sovrascritto da sottoclassi.

variabili

Una volta che una finalvariabile è stata inizializzata, contiene sempre lo stesso valore.

final sostanzialmente evitare di sovrascrivere / sovrascrivere qualsiasi cosa (sottoclassi, variabile "riassegnare"), a seconda del caso.

finalè una parola chiave riservata in Java per limitare l'utente e può essere applicata a variabili membro, metodi, classi e variabili locali. Le variabili finali sono spesso dichiarate con la staticparola chiave in Java e sono trattate come costanti. Per esempio:

public static final String hello = "Hello";

Quando utilizziamo la finalparola chiave con una dichiarazione di variabile, il valore memorizzato all'interno di quella variabile non può essere modificato in seguito.

Per esempio:

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

Nota : una classe dichiarata come final non può essere estesa o ereditata (ovvero, non può esserci una sottoclasse della superclasse). È anche bene notare che i metodi dichiarati come final non possono essere sovrascritti da sottoclassi.

I vantaggi dell'utilizzo della parola chiave finale sono trattati in questa discussione .

Supponiamo di avere due salvadanai, rosso e bianco. Assegni a questi salvadanai solo due bambini e non sono autorizzati a scambiare le loro caselle. Quindi hai dei salvadanai rossi o bianchi (finali) che non puoi modificare la scatola ma puoi mettere soldi sulla tua scatola. A nessuno importa (Modifica-2).

Leggi tutte le risposte

Esiste un altro caso utente in cui è finalpossibile utilizzare la parola chiave, ad esempio in un argomento del metodo:

public void showCaseFinalArgumentVariable(final int someFinalInt){

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

}

Può essere utilizzato per variabili che non devono essere modificate.

Quando lo rendi statico definitivo, dovrebbe essere inizializzato in un blocco di inizializzazione statico

    private static final List foo;

    static {
        foo = new ArrayList();
    }

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

La finalparola chiave indica che una variabile può essere inizializzata una sola volta. Nel tuo codice stai eseguendo solo un'inizializzazione di final, quindi i termini sono soddisfatti. Questa affermazione esegue l'inizializzazione solitaria di foo. Nota che final! = Immutabile, significa solo che il riferimento non può cambiare.

foo = new ArrayList();

Quando si dichiara foocome static finalvariabile deve essere inizializzata quando la classe viene caricata e non è possibile fare affidamento sull'istanza (ovvero chiamata al costruttore) per l'inizializzazione foopoiché i campi statici devono essere disponibili senza un'istanza di una classe. Non vi è alcuna garanzia che il costruttore sia stato chiamato prima di utilizzare il campo statico.

Quando si esegue il metodo nello static finalscenario, la Testclasse viene caricata prima di creare un'istanza tin questo momento, non vi è alcuna istanza di foosignificato che non è stata inizializzata, quindi fooè impostata sul valore predefinito per tutti gli oggetti null. A questo punto presumo che il tuo codice generi un NullPointerExceptionquando tenti di aggiungere un elemento all'elenco.

Prima di tutto, il posto nel tuo codice in cui stai inizializzando (ovvero assegnando per la prima volta) foo è qui:

foo = new ArrayList();

foo è un oggetto (con tipo Elenco) quindi è un tipo di riferimento , non un tipo di valore (come int). Come tale, contiene un riferimento a una posizione di memoria (ad es. 0xA7D2A834) in cui sono memorizzati gli elementi dell'elenco. Linee come questa

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

non modificare il valore di foo (che, di nuovo, è solo un riferimento a una posizione di memoria). Invece, aggiungono semplicemente elementi in quella posizione di memoria di riferimento. Per violare la parola chiave finale , dovresti provare a riassegnare foo di nuovo come segue:

foo = new ArrayList();

Che sarebbe darà un errore di compilazione.

Ora, a parte questo, pensa a cosa succede quando aggiungi la parola chiave statica .

Quando NON si dispone della parola chiave statica, ogni oggetto che crea un'istanza della classe ha la propria copia di pippo. Pertanto, il costruttore assegna un valore a una copia vuota e nuova della variabile foo, che è perfettamente a posto.

Tuttavia, quando si dispone della parola chiave statica, esiste solo un pippo in memoria associato alla classe. Se dovessi creare due o più oggetti, il costruttore tenterebbe di riassegnare quello uno ogni volta, violando la parola chiave finale .

1. Poiché la variabile finale non è statica, può essere inizializzata nel costruttore. Ma se lo rendi statico non può essere inizializzato dal costruttore (perché i costruttori non sono statici).
2. L'aggiunta all'elenco non dovrebbe essere interrotta rendendo l'elenco definitivo. finallega semplicemente il riferimento a un oggetto particolare. Sei libero di cambiare lo "stato" di quell'oggetto, ma non l'oggetto stesso.

Di seguito sono riportati diversi contesti in cui viene utilizzato final.

Variabili finali Una variabile finale può essere assegnata una sola volta. Se la variabile è un riferimento, ciò significa che la variabile non può essere rilegata per fare riferimento a un altro oggetto.

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

alla variabile finale può essere assegnato un valore in un secondo momento (non obbligatorio per assegnare un valore quando dichiarato), ma solo una volta.

Classi finali Una classe finale non può essere estesa (ereditata)

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

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

Metodi finali Un metodo finale non può essere ignorato dalle sottoclassi.

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

Ho pensato di scrivere una risposta aggiornata e approfondita qui.

final la parola chiave può essere utilizzata in diversi punti.

1. classi

Un final classsignifica che nessun'altra classe può estendere quella classe finale. Quando Java Run Time ( JRE ) sa che un riferimento a un oggetto è nel tipo di una classe finale (diciamo F), sa che il valore di quel riferimento può essere solo nel tipo di 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.

Pertanto, quando esegue qualsiasi metodo di tale oggetto, tale metodo non deve essere risolto in fase di esecuzione utilizzando una tabella virtuale . cioè il polimorfismo di runtime non può essere applicato. Quindi il tempo di esecuzione non si preoccupa di questo. Ciò significa che consente di risparmiare tempo di elaborazione, migliorando le prestazioni.

2. metodi

Una final methodclasse qualsiasi significa che qualsiasi classe figlio che estende quella classe non può sovrascrivere i metodi finali. Quindi il comportamento in fase di esecuzione in questo scenario è anche lo stesso del comportamento precedente che ho citato per le classi.

3. campi, variabili locali, parametri del metodo

Se uno ha specificato qualsiasi tipo di sopra come final, significa che il valore è già finalizzato, quindi il valore non può essere modificato .

Ex:

Per campi, parametri locali

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

Per i parametri del metodo

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

Ciò significa semplicemente che il valore del valore di finalriferimento non può essere modificato. cioè è consentita una sola inizializzazione. In questo scenario, in fase di esecuzione, poiché JRE sa che i valori non possono essere modificati, carica tutti questi valori finalizzati (dei riferimenti finali) nella cache L1 . Perché non ha bisogno di caricare indietro ancora e ancora dalla memoria principale . Altrimenti carica nella cache L2 e carica di volta in volta dalla memoria principale. Quindi è anche un miglioramento delle prestazioni.

Quindi, in tutti i 3 scenari sopra indicati, quando non abbiamo specificato la finalparola chiave in posti che possiamo usare, non dobbiamo preoccuparci, le ottimizzazioni del compilatore lo faranno per noi. Ci sono anche molte altre cose che le ottimizzazioni del compilatore fanno per noi. :)

Soprattutto sono corretti. Inoltre, se non desideri che altri creino sottoclassi dalla tua classe, allora dichiarale finale. Quindi diventa il livello foglia della gerarchia dell'albero della classe che nessuno può estenderlo ulteriormente. È buona norma evitare un'enorme gerarchia di classi.