Différence entre final et effectivement final

Je joue avec des lambdas dans Java 8 et je suis tombé sur un avertissement local variables referenced from a lambda expression must be final or effectively final. Je sais que lorsque j'utilise des variables à l'intérieur d'une classe anonyme, elles doivent être finales dans la classe externe, mais quand même - quelle est la différence entre final et effectivement final ?

... à partir de Java SE 8, une classe locale peut accéder aux variables et paramètres locaux du bloc englobant qui sont définitifs ou effectivement définitifs. Une variable ou un paramètre dont la valeur n'est jamais modifiée après son initialisation est effectivement définitif.

Par exemple, supposons que la variable numberLengthn'est pas déclarée finale et que vous ajoutez l'instruction d'affectation marquée dans le PhoneNumberconstructeur:

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

  ...

  }

...

}

En raison de cette instruction d'affectation, la variable numberLength n'est plus effectivement définitive. Par conséquent, le compilateur Java génère un message d'erreur similaire à «les variables locales référencées à partir d'une classe interne doivent être finales ou effectivement finales» où la classe interne PhoneNumber essaie d'accéder à la variable numberLength:

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

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

Je trouve que le moyen le plus simple d'expliquer "effectivement final" est d'imaginer ajouter le finalmodificateur à une déclaration de variable. Si, avec ce changement, le programme continue de se comporter de la même manière, à la fois au moment de la compilation et au moment de l'exécution, alors cette variable est effectivement définitive.

Selon les documents :

Une variable ou un paramètre dont la valeur n'est jamais modifiée après son initialisation est effectivement définitif.

Fondamentalement, si le compilateur trouve qu'une variable n'apparaît pas dans les affectations en dehors de son initialisation, alors la variable est considérée comme effectivement finale .

Par exemple, considérez une classe:

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

«Effectivement final» est une variable qui ne donnerait pas d'erreur de compilation si elle était ajoutée par «final»

D'après un article de «Brian Goetz»,

De manière informelle, une variable locale est effectivement finale si sa valeur initiale n'est jamais modifiée - en d'autres termes, la déclarer finale ne provoquerait pas un échec de compilation.

lambda-state-final- Brian Goetz

Cette variable ci-dessous est finale , nous ne pouvons donc pas changer sa valeur une fois initialisée. Si nous essayons, nous obtiendrons une erreur de compilation ...

final int variable = 123;

Mais si nous créons une variable comme celle-ci, nous pouvons changer sa valeur ...

int variable = 123;
variable = 456;

Mais en Java 8 , toutes les variables sont finales par défaut. Mais l'existence de la 2ème ligne dans le code la rend non définitive . Donc, si nous supprimons la 2ème ligne du code ci-dessus, notre variable est désormais "effectivement définitive" ...

int variable = 123;

Donc .. Toute variable assignée une seule fois est "effectivement définitive" .

Une variable est finale ou effectivement finale lorsqu'elle est initialisée une fois et qu'elle n'est jamais mutée dans sa classe propriétaire. Et nous ne pouvons pas l'initialiser en boucles ou en classes internes .

Finale :

final int number;
number = 23;

Effectivement final :

int number;
number = 34;

Remarque : Final et Final Final sont similaires (leur valeur ne change pas après l'affectation) mais juste que les variables finales effectives ne sont pas déclarées avec le mot-clé final.

Lorsqu'une expression lambda utilise une variable locale affectée à partir de son espace englobant, il existe une restriction importante. Une expression lambda peut uniquement utiliser une variable locale dont la valeur ne change pas. Cette restriction est appelée " capture variable ", qui est décrite comme; l'expression lambda capture des valeurs, pas des variables .
Les variables locales qu'une expression lambda peut utiliser sont dites " effectivement finales ".
Une variable effectivement finale est une variable dont la valeur ne change pas après sa première affectation. Il n'est pas nécessaire de déclarer explicitement une telle variable comme finale, bien que cela ne soit pas une erreur.
Voyons-le avec un exemple, nous avons une variable locale i qui est initialisée avec la valeur 7, avec dans l'expression lambda nous essayons de changer cette valeur en assignant une nouvelle valeur à i. Cela entraînera une erreur du compilateur - « La variable locale i définie dans une étendue englobante doit être finale ou effectivement finale »

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

Le sujet final efficace est décrit dans JLS 4.12.4 et le dernier paragraphe comprend une explication claire:

Si une variable est effectivement finale, l'ajout du modificateur final à sa déclaration n'introduira aucune erreur au moment de la compilation. Inversement, une variable ou un paramètre local qui est déclaré final dans un programme valide devient effectivement définitif si le dernier modificateur est supprimé.

final est une variable declare avec mot clé final, exemple:

final double pi = 3.14 ;

il reste tout au finallong du programme.

effectivement finale : toute variable ou paramètre local auquel une valeur n'est attribuée qu'une seule fois maintenant (ou mise à jour une seule fois). Il peut ne pas rester effectivement définitif long du programme. cela signifie donc que la variable effectivement finale peut perdre sa propriété effectivement finale après le moment où elle est affectée / mise à jour au moins une autre affectation. exemple:

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; 

        }
    }    
}

Comme d'autres l'ont dit, une variable ou un paramètre dont la valeur n'est jamais modifiée après son initialisation est effectivement définitif. Dans le code ci-dessus, si vous modifiez la valeur de xdans la classe interne, FirstLevelle compilateur vous donnera le message d'erreur:

Les variables locales référencées à partir d'une expression lambda doivent être finales ou effectivement finales.

Si vous pouviez ajouter le finalmodificateur à une variable locale, c'était effectivement définitif.

Les expressions lambda peuvent accéder

• variables statiques,

• variables d'instance,

• des paramètres de méthode finaux efficaces, et

• variables locales finales efficaces.

Source: OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide, Jeanne Boyarsky, Scott Selikoff

Aditionellement,

Une effectively finalvariable est une variable dont la valeur n'est jamais modifiée, mais elle n'est pas déclarée avec le finalmot clé.

Source: Commencer avec Java: des structures de contrôle aux objets (6e édition), Tony Gaddis

De plus, n'oubliez pas le sens de finalce qu'il est initialisé exactement une fois avant d'être utilisé pour la première fois.

Déclarer une variable finalou ne pas la déclarer final, mais la garder effectivement finale peut entraîner (dépend du compilateur) un bytecode différent.

Jetons un coup d'œil sur un petit exemple:

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

Le bytecode correspondant de la mainméthode (Java 8u161 sur 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 table des numéros de ligne correspondante:

 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

Comme on le voit le code source au niveau des lignes 12, 13, 14ne figure pas dans le code d'octets. C'est parce que ic'est trueet ne changera pas son état. Ainsi, ce code est inaccessible (plus dans cette réponse ). Pour la même raison, le code à la ligne 9manque également. Il in'est pas nécessaire d'évaluer l'état de car il est truecertain.

D'un autre côté, bien que la variable jsoit effectivement finale, elle n'est pas traitée de la même manière. Il n'y a pas de telles optimisations appliquées. L'état de jest évalué deux fois. Le bytecode est le même, même s'il jest effectivement définitif .

La variable effectivement finale est une variable locale qui est:

1. Non défini comme final
2. Attribué à SEULEMENT une fois.

Alors qu'une variable finale est une variable qui est:

1. déclaré avec un finalmot clé.

Cependant, à partir de Java SE 8, une classe locale peut accéder aux variables et paramètres locaux du bloc englobant qui sont définitifs ou effectivement définitifs.

Cela n'a pas commencé sur Java 8, je l'utilise depuis longtemps. Ce code utilisé (avant java 8) était légal:

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