Diferença entre final e efetivamente final

Estou brincando com lambdas no Java 8 e me deparei com um aviso local variables referenced from a lambda expression must be final or effectively final. Eu sei que quando eu uso variáveis ​​dentro da classe anônima, elas devem ser finais na classe externa, mas ainda assim - qual é a diferença entre final e efetivamente final ?

... a partir do Java SE 8, uma classe local pode acessar variáveis ​​e parâmetros locais do bloco anexo que são finais ou efetivamente finais. Uma variável ou parâmetro cujo valor nunca é alterado após a inicialização é efetivamente final.

Por exemplo, suponha que a variável numberLengthnão seja declarada final e você adicione a instrução de atribuição marcada no PhoneNumberconstrutor:

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

  ...

  }

...

}

Por causa dessa declaração de atribuição, a variável numberLength não é mais definitiva. Como resultado, o compilador Java gera uma mensagem de erro semelhante a "variáveis ​​locais referenciadas de uma classe interna devem ser finais ou efetivamente finais" onde a classe interna PhoneNumber tenta acessar a variável numberLength:

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

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

Acho que a maneira mais simples de explicar "efetivamente final" é imaginar adicionar o finalmodificador a uma declaração de variável. Se, com essa alteração, o programa continuar a se comportar da mesma maneira, tanto em tempo de compilação quanto em tempo de execução, essa variável será efetivamente final.

De acordo com os documentos :

Uma variável ou parâmetro cujo valor nunca é alterado após a inicialização é efetivamente final.

Basicamente, se o compilador descobrir que uma variável não aparece nas atribuições fora de sua inicialização, a variável será considerada efetivamente final .

Por exemplo, considere alguma 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;
    }
}

'Efetivamente final' é uma variável que não daria erro ao compilador se fosse anexado por 'final'

De um artigo de 'Brian Goetz',

Informalmente, uma variável local é efetivamente final se seu valor inicial nunca for alterado - em outras palavras, declarar final não causaria uma falha de compilação.

final de estado de lambda- Brian Goetz

Essa variável abaixo é final , portanto, não podemos alterar seu valor uma vez inicializado. Se tentarmos, obteremos um erro de compilação ...

final int variable = 123;

Mas se criarmos uma variável como essa, podemos mudar seu valor ...

int variable = 123;
variable = 456;

Mas no Java 8 , todas as variáveis ​​são finais por padrão. Mas a existência da 2ª linha no código a torna não final . Portanto, se removermos a segunda linha do código acima, nossa variável agora é "efetivamente final" ...

int variable = 123;

Portanto, qualquer variável atribuída uma e apenas uma vez é "efetivamente final" .

Uma variável é final ou efetivamente final quando é inicializada uma vez e nunca é alterada em sua classe de proprietário. E não podemos inicializá- lo em loops ou classes internas .

Final :

final int number;
number = 23;

Efetivamente Final :

int number;
number = 34;

Nota : Final e Final efetivo são semelhantes (seu valor não muda após a atribuição), mas apenas as variáveis ​​finais efetivas não são declaradas com Palavra-chave final.

Quando uma expressão lambda usa uma variável local atribuída de seu espaço em anexo, há uma restrição importante. Uma expressão lambda pode usar apenas variável local cujo valor não muda. Essa restrição é referida como " captura variável ", que é descrita como; valores de captura de expressão lambda, não variáveis .
As variáveis ​​locais que uma expressão lambda pode usar são conhecidas como " efetivamente finais ". Vamos ver com um exemplo: temos uma variável local i que é inicializada com o valor 7; na expressão lambda, estamos tentando alterar esse valor atribuindo um novo valor a i. Isso resultará em erro do compilador - "
Uma variável efetivamente final é aquela cujo valor não muda após a primeira atribuição. Não há necessidade de declarar explicitamente uma variável como final, embora isso não seja um erro.

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

O tópico final efetivo é descrito no JLS 4.12.4 e o último parágrafo consiste em uma explicação clara:

Se uma variável for efetivamente final, adicionar o modificador final à sua declaração não introduzirá nenhum erro em tempo de compilação. Por outro lado, uma variável local ou parâmetro declarado final em um programa válido se torna efetivamente final se o modificador final for removido.

final é uma variável declarada com palavra-chave final, exemplo:

final double pi = 3.14 ;

permanece finaldurante todo o programa.

efetivamente final : qualquer variável local ou parâmetro ao qual seja atribuído um valor apenas uma vez no momento (ou atualizado apenas uma vez). Pode não permanecer efetivamente final durante todo o programa. portanto, isso significa que a variável efetivamente final pode perder sua propriedade efetivamente final após o tempo em que é atribuída / atualizada pelo menos mais uma atribuição. exemplo:

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; 

        }
    }    
}

Como já foi dito, uma variável ou parâmetro cujo valor nunca é alterado após a inicialização é efetivamente final. No código acima, se você alterar o valor de xna classe interna FirstLevel, o compilador exibirá a mensagem de erro:

Variáveis ​​locais referenciadas a partir de uma expressão lambda devem ser finais ou efetivamente finais.

Se você pudesse adicionar o finalmodificador a uma variável local, ele seria efetivamente final.

Expressões lambda podem acessar

• variáveis ​​estáticas,

• variáveis ​​de instância,

• efetivamente parâmetros finais do método, e

• efetivamente variáveis ​​locais finais.

Fonte: OCP: Guia de Estudo do Oracle Certified Professional Java SE 8 Programmer II da Oracle, Jeanne Boyarsky, Scott Selikoff

Além disso,

Uma effectively finalvariável é uma variável cujo valor nunca é alterado, mas não é declarado com a finalpalavra - chave.

Fonte: Iniciando com Java: das estruturas de controle aos objetos (6ª edição), Tony Gaddis

Além disso, não esqueça o significado de finalque ele foi inicializado exatamente uma vez antes de ser usado pela primeira vez.

Declarar uma variável finalou não final, mas mantê-la efetivamente final pode resultar (depende do compilador) em bytecode diferente.

Vamos dar uma olhada em um pequeno exemplo:

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

O bytecode correspondente do mainmétodo (Java 8u161 no 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

A tabela de número de linha correspondente:

 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

Como podemos ver o código-fonte em linhas 12, 13, 14não aparecem no código byte. Isso é porque ié truee não mudará seu estado. Portanto, este código está inacessível (mais nesta resposta ). Pela mesma razão, o código na linha 9também falha. O estado de inão precisa ser avaliado, pois é truecerto.

Por outro lado, embora a variável jseja efetivamente final, ela não é processada da mesma maneira. Não existem essas otimizações aplicadas. O estado de jé avaliado duas vezes. O bytecode é o mesmo, independentemente de jser efetivamente final .

A variável Efetivamente final é uma variável local que é:

1. Não definido como final
2. Atribuído a APENAS uma vez.

Enquanto uma variável final é uma variável que é:

1. declarado com uma finalpalavra - chave.

No entanto, a partir do Java SE 8, uma classe local pode acessar variáveis ​​e parâmetros locais do bloco anexo que são finais ou efetivamente finais.

Isso não começou no Java 8, eu uso isso há muito tempo. Este código usado (antes do java 8) é legal:

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