Differenza tra finale ed effettivamente finale

Sto giocando con lambdas in Java 8 e mi sono imbattuto in avvertimento local variables referenced from a lambda expression must be final or effectively final. So che quando uso variabili all'interno della classe anonima devono essere final nella classe esterna, ma comunque - qual è la differenza tra final ed effettivamente final ?

... a partire da Java SE 8, una classe locale può accedere a variabili e parametri locali del blocco che li racchiude in modo definitivo o finale. Una variabile o un parametro il cui valore non viene mai modificato dopo l'inizializzazione è effettivamente finale.

Ad esempio, supponi che la variabile numberLengthnon sia dichiarata finale e aggiungi l'istruzione di assegnazione contrassegnata nel PhoneNumbercostruttore:

public class OutterClass {  

  int numberLength; // <== not *final*

  class PhoneNumber {

    PhoneNumber(String phoneNumber) {
        numberLength = 7;   // <== assignment to numberLength
        String currentNumber = phoneNumber.replaceAll(
            regularExpression, "");
        if (currentNumber.length() == numberLength)
            formattedPhoneNumber = currentNumber;
        else
            formattedPhoneNumber = null;
     }

  ...

  }

...

}

A causa di questa istruzione di assegnazione, la variabile numberLength non è più effettivamente definitiva. Di conseguenza, il compilatore Java genera un messaggio di errore simile a "Le variabili locali a cui fa riferimento una classe interna devono essere finali o effettivamente finali" in cui la classe interna PhoneNumber tenta di accedere alla variabile numberLength:

http://codeinventions.blogspot.in/2014/07/difference-between-final-and.html

http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html

Trovo che il modo più semplice per spiegare "efficacemente finale" sia immaginare di aggiungere il finalmodificatore a una dichiarazione variabile. Se, con questa modifica, il programma continua a comportarsi allo stesso modo, sia in fase di compilazione che in fase di esecuzione, tale variabile è effettivamente definitiva.

Secondo i documenti :

Una variabile o un parametro il cui valore non viene mai modificato dopo l'inizializzazione è effettivamente finale.

Fondamentalmente, se il compilatore trova una variabile non appare in incarichi al di fuori della sua inizializzazione, allora la variabile viene considerata effettivamente definitiva .

Ad esempio, considera alcune classi:

public class Foo {

    public void baz(int bar) {
        // While the next line is commented, bar is effectively final
        // and while it is uncommented, the assignment means it is not
        // effectively final.

        // bar = 2;
    }
}

'Efficace final' è una variabile che non darebbe l'errore del compilatore se fosse aggiunto da 'final'

Da un articolo di "Brian Goetz",

Informalmente, una variabile locale è effettivamente definitiva se il suo valore iniziale non viene mai modificato - in altre parole, dichiararla finale non causerebbe un errore di compilazione.

lambda-stato-finale- Brian Goetz

Questa variabile di seguito è definitiva , quindi non possiamo cambiarne il valore una volta inizializzata. Se proviamo a ricevere un errore di compilazione ...

final int variable = 123;

Ma se creiamo una variabile come questa, possiamo cambiarne il valore ...

int variable = 123;
variable = 456;

Ma in Java 8 , tutte le variabili sono definitive per impostazione predefinita. Ma l'esistenza della seconda riga nel codice la rende non definitiva . Quindi, se rimuoviamo la seconda riga dal codice sopra, la nostra variabile è ora "effettivamente definitiva" ...

int variable = 123;

Quindi .. Qualsiasi variabile assegnata una sola e una sola volta è "effettivamente definitiva" .

Una variabile è definitiva o efficacemente finale quando è inizializzato una volta e non è mai mutato nella sua classe di appartenenza. E non possiamo inizializzarlo in loop o classi interne .

Finale :

final int number;
number = 23;

Effettivamente finale :

int number;
number = 34;

Nota : Final ed Effective Final sono simili (il loro valore non cambia dopo l'assegnazione) ma solo le variabili Final effettive non vengono dichiarate con Keyword final.

Quando un'espressione lambda utilizza una variabile locale assegnata dal suo spazio racchiuso, esiste un'importante limitazione. Un'espressione lambda può usare solo una variabile locale il cui valore non cambia. Tale restrizione è definita " acquisizione variabile " che è descritta come; L'espressione lambda acquisisce valori, non variabili .
Le variabili locali che un'espressione lambda può usare sono conosciute come " effettivamente finali ".
Una variabile effettivamente finale è una variabile il cui valore non cambia dopo che è stato assegnato per la prima volta. Non è necessario dichiarare esplicitamente una variabile come final, anche se farlo non sarebbe un errore.
Vediamolo con un esempio, abbiamo una variabile locale i che è inizializzata con il valore 7, con l'espressione lambda stiamo provando a cambiare quel valore assegnando un nuovo valore a i. Ciò comporterà un errore del compilatore: " La variabile locale che ho definito in un ambito che racchiude deve essere finale o effettivamente definitiva "

@FunctionalInterface
interface IFuncInt {
    int func(int num1, int num2);
    public String toString();
}

public class LambdaVarDemo {

    public static void main(String[] args){             
        int i = 7;
        IFuncInt funcInt = (num1, num2) -> {
            i = num1 + num2;
            return i;
        };
    }   
}

L' argomento finale efficace è descritto in JLS 4.12.4 e l'ultimo paragrafo contiene una chiara spiegazione:

Se una variabile è effettivamente definitiva, l'aggiunta del modificatore finale alla sua dichiarazione non introdurrà alcun errore di compilazione. Al contrario, una variabile locale o un parametro dichiarato finale in un programma valido diventa effettivamente finale se il modificatore finale viene rimosso.

final è una variabile dichiarata con la parola chiave final, esempio:

final double pi = 3.14 ;

rimane finalper tutto il programma.

efficacemente finale : qualsiasi variabile locale o parametro a cui viene assegnato un valore solo una volta in questo momento (o aggiornato solo una volta). Potrebbe non rimanere efficacemente definitivo per tutto il programma. quindi ciò significa che la variabile finale effettiva potrebbe perdere la sua proprietà finale effettiva dopo il momento in cui viene assegnata / aggiornata almeno un'altra assegnazione. esempio:

class EffectivelyFinal {

    public static void main(String[] args) {
        calculate(124,53);
    }

    public static void calculate( int operand1, int operand2){   
     int rem = 0;  //   operand1, operand2 and rem are effectively final here
     rem = operand1%2  // rem lost its effectively final property here because it gets its second assignment 
                       // operand1, operand2 are still effectively final here 
        class operators{

            void setNum(){
                operand1 =   operand2%2;  // operand1 lost its effectively final property here because it gets its second assignment
            }

            int add(){
                return rem + operand2;  // does not compile because rem is not effectively final
            }
            int multiply(){
                return rem * operand1;  // does not compile because both rem and operand1 are not effectively final
            }
        }   
   }    
}

public class LambdaScopeTest {
    public int x = 0;        
    class FirstLevel {
        public int x = 1;    
        void methodInFirstLevel(int x) {

            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99; 

        }
    }    
}

Come altri hanno già detto, una variabile o parametro il cui valore non viene mai modificato dopo l'inizializzazione è effettivamente definitivo. Nel codice precedente, se si modifica il valore di xin classe interna, FirstLevelil compilatore restituirà il messaggio di errore:

Le variabili locali a cui fa riferimento un'espressione lambda devono essere definitive o effettivamente definitive.

Se potevi aggiungere il finalmodificatore a una variabile locale, era effettivamente definitivo.

Le espressioni lambda possono accedere

• variabili statiche,

• variabili di istanza,

• parametri del metodo effettivamente finali e

• variabili locali effettivamente finali.

Fonte: OCP: Oracle Study Professional Java SE 8 Programmer II Guida allo studio, Jeanne Boyarsky, Scott Selikoff

Inoltre,

Una effectively finalvariabile è una variabile il cui valore non viene mai modificato, ma non viene dichiarato con la finalparola chiave.

Fonte: A partire da Java: da Control Structures a Objects (6a edizione), Tony Gaddis

Inoltre, non dimenticare il significato di finalche è inizializzato esattamente una volta prima di essere usato per la prima volta.

Dichiarare una variabile finalo non dichiararla final, ma mantenerla effettivamente definitiva può comportare (dipende dal compilatore) un diverso bytecode.

Diamo un'occhiata a un piccolo esempio:

    public static void main(String[] args) {
        final boolean i = true;   // 6  // final by declaration
        boolean j = true;         // 7  // effectively final

        if (i) {                  // 9
            System.out.println(i);// 10
        }
        if (!i) {                 // 12
            System.out.println(i);// 13
        }
        if (j) {                  // 15
            System.out.println(j);// 16
        }
        if (!j) {                 // 18
            System.out.println(j);// 19
        }
    }

Il bytecode corrispondente del mainmetodo (Java 8u161 su Windows 64 bit):

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_1
       3: istore_2
       4: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       7: iconst_1
       8: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      11: iload_2
      12: ifeq          22
      15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      18: iload_2
      19: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      22: iload_2
      23: ifne          33
      26: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      29: iload_2
      30: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      33: return

La tabella dei numeri di riga corrispondente:

 LineNumberTable:
   line 6: 0
   line 7: 2
   line 10: 4
   line 15: 11
   line 16: 15
   line 18: 22
   line 19: 26
   line 21: 33

Come si vede il codice sorgente a linee 12, 13, 14non appare nel bytecode. Questo perché iè truee non cambierà il suo stato. Quindi questo codice non è raggiungibile (più in questa risposta ). Per lo stesso motivo 9manca anche il codice in linea . Lo stato di inon deve essere valutato poiché è truesicuro.

D'altra parte, sebbene la variabile jsia effettivamente definitiva , non viene elaborata allo stesso modo. Non sono state applicate tali ottimizzazioni. Lo stato di jviene valutato due volte. Il bytecode è lo stesso indipendentemente jdall'essere effettivamente definitivo .

La variabile efficacemente finale è una variabile locale che è:

1. Non definito come final
2. Assegnato a SOLO una volta.

Mentre una variabile finale è una variabile che è:

1. dichiarato con una finalparola chiave.

Tuttavia, a partire da Java SE 8, una classe locale può accedere a variabili e parametri locali del blocco> che sono finali o effettivamente finali.

Questo non è iniziato su Java 8, lo uso da molto tempo. Questo codice utilizzava (prima di Java 8) per essere legale:

String str = ""; //<-- not accesible from anonymous classes implementation
final String strFin = ""; //<-- accesible 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
         String ann = str; // <---- error, must be final (IDE's gives the hint);
         String ann = strFin; // <---- legal;
         String str = "legal statement on java 7,"
                +"Java 8 doesn't allow this, it thinks that I'm trying to use the str declared before the anonymous impl."; 
         //we are forced to use another name than str
    }
);