Unterschied zwischen endgültig und effektiv endgültig

Ich spiele mit Lambdas in Java 8 und bin auf eine Warnung gestoßen local variables referenced from a lambda expression must be final or effectively final. Ich weiß, dass Variablen, die in einer anonymen Klasse verwendet werden, in der äußeren Klasse endgültig sein müssen, aber dennoch - was ist der Unterschied zwischen endgültig und effektiv endgültig ?

... ab Java SE 8 kann eine lokale Klasse auf lokale Variablen und Parameter des umschließenden Blocks zugreifen, die endgültig oder effektiv endgültig sind. Eine Variable oder ein Parameter, dessen Wert nach der Initialisierung niemals geändert wird, ist effektiv endgültig.

Angenommen, die Variable numberLengthwird nicht als endgültig deklariert, und Sie fügen die markierte Zuweisungsanweisung im PhoneNumberKonstruktor hinzu:

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

  ...

  }

...

}

Aufgrund dieser Zuweisungsanweisung ist die Variable numberLength nicht mehr endgültig. Infolgedessen generiert der Java-Compiler eine Fehlermeldung ähnlich der Meldung "Lokale Variablen, auf die von einer inneren Klasse verwiesen wird, müssen endgültig oder effektiv endgültig sein", wobei die innere Klasse PhoneNumber versucht, auf die Variable numberLength zuzugreifen:

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

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

Ich finde, der einfachste Weg, "effektiv endgültig" zu erklären, besteht darin, sich vorzustellen, den finalModifikator einer Variablendeklaration hinzuzufügen . Wenn sich das Programm mit dieser Änderung sowohl zur Kompilierungszeit als auch zur Laufzeit weiterhin auf dieselbe Weise verhält, ist diese Variable effektiv endgültig.

Laut den Dokumenten :

Eine Variable oder ein Parameter, dessen Wert nach der Initialisierung niemals geändert wird, ist effektiv endgültig.

Wenn der Compiler feststellt, dass eine Variable nicht in Zuweisungen außerhalb ihrer Initialisierung angezeigt wird, wird die Variable als effektiv endgültig betrachtet .

Betrachten Sie zum Beispiel eine Klasse:

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

'Effectively final' ist eine Variable, die keinen Compilerfehler ausgibt, wenn sie an 'final' angehängt wird.

Aus einem Artikel von 'Brian Goetz',

Informell ist eine lokale Variable effektiv endgültig, wenn ihr Anfangswert nie geändert wird. Mit anderen Worten, wenn sie als endgültig deklariert wird, führt dies nicht zu einem Kompilierungsfehler.

Lambda-State-Finale-Brian Goetz

Diese Variable unten ist endgültig , daher können wir ihren Wert nach der Initialisierung nicht mehr ändern. Wenn wir es versuchen, erhalten wir einen Kompilierungsfehler ...

final int variable = 123;

Aber wenn wir eine Variable wie diese erstellen, können wir ihren Wert ändern ...

int variable = 123;
variable = 456;

In Java 8 sind jedoch standardmäßig alle Variablen endgültig . Das Vorhandensein der zweiten Zeile im Code macht sie jedoch nicht endgültig . Wenn wir also die 2. Zeile aus dem obigen Code entfernen, ist unsere Variable jetzt "effektiv endgültig" ...

int variable = 123;

Also .. Jede Variable, die einmal und nur einmal zugewiesen wird, ist "effektiv endgültig" .

Eine Variable ist endgültig oder effektiv endgültig, wenn sie einmal initialisiert wird und in ihrer Eigentümerklasse niemals mutiert ist . Und wir können es nicht in Schleifen oder inneren Klassen initialisieren .

Finale :

final int number;
number = 23;

Effektiv endgültig :

int number;
number = 34;

Hinweis : Final und Effective Final sind ähnlich (ihr Wert ändert sich nach der Zuweisung nicht), aber nur die effektiven Final-Variablen werden nicht mit Keyword deklariert final.

Wenn ein Lambda-Ausdruck eine zugewiesene lokale Variable aus seinem umschließenden Raum verwendet, gibt es eine wichtige Einschränkung. Ein Lambda-Ausdruck darf nur lokale Variablen verwenden, deren Wert sich nicht ändert. Diese Einschränkung wird als " Variablenerfassung " bezeichnet, die beschrieben wird als; Erfassungswerte für Lambda-Ausdrücke, keine Variablen .
Die lokalen Variablen, die ein Lambda-Ausdruck verwenden kann, werden als " effektiv endgültig " bezeichnet.
Eine effektiv endgültige Variable ist eine Variable, deren Wert sich nach der ersten Zuweisung nicht ändert. Es ist nicht erforderlich, eine solche Variable explizit als final zu deklarieren, obwohl dies kein Fehler wäre.
Schauen wir uns ein Beispiel an: Wir haben eine lokale Variable i, die mit dem Wert 7 initialisiert wird. Im Lambda-Ausdruck versuchen wir, diesen Wert zu ändern, indem wir i einen neuen Wert zuweisen. Dies führt zu einem Compilerfehler - " Die in einem umschließenden Bereich definierte lokale Variable i muss endgültig oder effektiv endgültig sein. "

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

Das effektive letzte Thema ist in JLS 4.12.4 beschrieben und der letzte Absatz enthält eine klare Erklärung:

Wenn eine Variable effektiv endgültig ist, führt das Hinzufügen des endgültigen Modifikators zu ihrer Deklaration zu keinen Fehlern bei der Kompilierung. Umgekehrt wird eine lokale Variable oder ein lokaler Parameter, der in einem gültigen Programm als endgültig deklariert wird, effektiv endgültig, wenn der endgültige Modifikator entfernt wird.

final ist eine Variable deklarieren mit Schlüsselwort final, Beispiel:

final double pi = 3.14 ;

es bleibt finalwährend des gesamten Programms.

effektiv endgültig : Jede lokale Variable oder jeder lokale Parameter, dem derzeit nur einmal ein Wert zugewiesen wird (oder der nur einmal aktualisiert wird). Es kann sein, dass es während des gesamten Programms nicht effektiv endgültig bleibt . Dies bedeutet also, dass die effektiv endgültige Variable ihre effektiv endgültige Eigenschaft verlieren kann, sobald sie mindestens eine weitere Zuweisung zugewiesen / aktualisiert hat. Beispiel:

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; 

        }
    }    
}

Wie andere gesagt haben, ist eine Variable oder ein Parameter, dessen Wert nach der Initialisierung niemals geändert wird, effektiv endgültig. Wenn Sie im obigen Code den Wert von xin der inneren Klasse ändern, gibt FirstLevelder Compiler die folgende Fehlermeldung aus:

Lokale Variablen, auf die aus einem Lambda-Ausdruck verwiesen wird, müssen endgültig oder effektiv endgültig sein.

Wenn Sie den finalModifikator einer lokalen Variablen hinzufügen konnten , war er effektiv endgültig.

Lambda-Ausdrücke können darauf zugreifen

• statische Variablen,

• Instanzvariablen,

• effektiv endgültige Methodenparameter und

• effektiv endgültige lokale Variablen.

Quelle: OCP: Oracle Certified Professional Java SE 8 Programmer II-Studienhandbuch, Jeanne Boyarsky, Scott Selikoff

Zusätzlich,

Eine effectively finalVariable ist eine Variable, deren Wert niemals geändert wird, die jedoch nicht mit dem finalSchlüsselwort deklariert wird.

Quelle: Beginnend mit Java: Von Kontrollstrukturen über Objekte (6. Ausgabe), Tony Gaddis

Vergessen Sie außerdem nicht, finaldass es genau einmal initialisiert wird, bevor es zum ersten Mal verwendet wird.

Wenn Sie eine Variable finaldeklarieren oder nicht deklarieren, sie finaljedoch endgültig halten, kann dies (abhängig vom Compiler) zu einem anderen Bytecode führen.

Schauen wir uns ein kleines Beispiel an:

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

Der entsprechende Bytecode der mainMethode (Java 8u161 unter 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

Die entsprechende Zeilennummertabelle:

 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

Da wir den Quellcode an den Linien zu sehen 12, 13, 14erscheint nicht in dem Byte - Code. Das iliegt truedaran, dass es seinen Zustand ändert und nicht ändern wird. Daher ist dieser Code nicht erreichbar (mehr in dieser Antwort ). Aus dem gleichen Grund 9fehlt auch der Code in der Zeile . Der Zustand von imuss nicht ausgewertet werden, da dies truesicher ist.

Auf der anderen Seite ist die Variable jzwar endgültig, wird aber nicht auf die gleiche Weise verarbeitet. Es werden keine derartigen Optimierungen angewendet. Der Zustand von jwird zweimal ausgewertet. Der Bytecode ist derselbe, unabhängig davon j, ob er tatsächlich endgültig ist .

Ab Java SE 8 kann eine lokale Klasse jedoch auf lokale Variablen und Parameter des> umschließenden Blocks zugreifen, die endgültig oder effektiv endgültig sind.

Dies begann nicht mit Java 8, ich benutze dies seit langer Zeit. Dieser Code wurde (vor Java 8) verwendet, um legal zu sein:

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