Разница между окончательным и фактически окончательным

Я играю с лямбдами в Java 8, и я столкнулся с предупреждением local variables referenced from a lambda expression must be final or effectively final. Я знаю, что когда я использую переменные внутри анонимного класса, они должны быть финальными во внешнем классе, но все же - в чем разница между финальными и эффективно финальными ?

... начиная с Java SE 8, локальный класс может обращаться к локальным переменным и параметрам заключающего блока, которые являются окончательными или фактически конечными. Переменная или параметр, значение которых никогда не изменяется после его инициализации, фактически является окончательным.

Например, предположим, что переменная numberLengthне объявлена ​​как финальная, и вы добавили отмеченный оператор присваивания в PhoneNumberконструктор:

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

  ...

  }

...

}

Из-за этого оператора присваивания переменная numberLength больше не является окончательной. В результате компилятор Java генерирует сообщение об ошибке, похожее на «локальные переменные, на которые ссылается внутренний класс, должны быть окончательными или эффективно окончательными», когда внутренний класс PhoneNumber пытается получить доступ к переменной numberLength:

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

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

Я считаю, что самый простой способ объяснить «эффективно окончательный» - это представить добавление finalмодификатора к объявлению переменной. Если с этим изменением программа продолжает вести себя одинаково, как во время компиляции, так и во время выполнения, то эта переменная будет фактически финальной.

Согласно документам :

Переменная или параметр, значение которых никогда не изменяется после его инициализации, фактически является окончательным.

По сути, если компилятор обнаруживает, что переменная не появляется в присваиваниях за пределами ее инициализации, то эта переменная считается фактически конечной .

Например, рассмотрим некоторый класс:

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' - это переменная, которая не выдаст ошибку компилятора, если она будет добавлена ​​'final'

Из статьи Брайана Гетца,

Неформально, локальная переменная является окончательной, если ее начальное значение никогда не изменяется - иными словами, объявление ее окончательным не приведет к сбою компиляции.

лямбда-государство-финал- Брайан Гетц

Эта переменная ниже является окончательной , поэтому мы не можем изменить ее значение после инициализации. Если мы попытаемся, мы получим ошибку компиляции ...

final int variable = 123;

Но если мы создадим такую ​​переменную, мы можем изменить ее значение ...

int variable = 123;
variable = 456;

Но в Java 8 все переменные являются окончательными по умолчанию. Но наличие 2-й строки в коде делает его не окончательным . Так что, если мы уберем 2 - й строки из кода выше, наша переменная теперь «эффективно окончательный» ...

int variable = 123;

Итак ... Любая переменная, которая назначается один раз и только один раз, является "эффективно конечной" .

Переменная является окончательной или фактически конечной, когда она инициализируется один раз и никогда не мутирует в своем классе владельца. И мы не можем инициализировать его в циклах или внутренних классах .

Финал :

final int number;
number = 23;

Эффективно финал :

int number;
number = 34;

Примечание : Final и Effective Final похожи (их значение не изменяется после назначения), но только то, что эффективные переменные Final не объявляются с помощью ключевого слова final.

Когда лямбда-выражение использует назначенную локальную переменную из окружающего пространства, существует важное ограничение. Лямбда-выражение может использовать только локальную переменную, значение которой не изменяется. Это ограничение называется « захват переменной », который описывается как; лямбда-выражения захватывают значения, а не переменные .
Локальные переменные, которые может использовать лямбда-выражение, известны как « эффективно финальные ».
Фактически последняя переменная - это переменная, значение которой не изменяется после ее первого назначения. Нет необходимости явно объявлять такую ​​переменную как final, хотя это не будет ошибкой.
Давайте рассмотрим это на примере, у нас есть локальная переменная i, которая инициализируется значением 7, и в лямбда-выражении мы пытаемся изменить это значение, присваивая новое значение i. Это приведет к ошибке компилятора - « Локальная переменная i, определенная во включающей области видимости, должна быть конечной или фактически конечной »

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

Эффективная последняя тема описана в JLS 4.12.4, а последний абзац содержит четкое объяснение:

Если переменная является окончательной, то добавление модификатора final к ее объявлению не приведет к ошибкам во время компиляции. И наоборот, локальная переменная или параметр, который объявлен окончательным в допустимой программе, становится фактически конечным, если модификатор final удаляется.

final - объявить переменную с ключевым словом final, пример:

final double pi = 3.14 ;

это остается finalчерез программу.

фактически окончательный : любая локальная переменная или параметр, которому присваивается значение только один раз (или обновляется только один раз). Это может не оставаться эффективно окончательным в течение всей программы. таким образом, это означает, что эффективная конечная переменная может потерять свое фактически конечное свойство сразу после того, как она получит / обновит по крайней мере еще одно назначение. пример:

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; 

        }
    }    
}

Как уже говорили другие, переменная или параметр, значение которых никогда не изменяется после инициализации, фактически является окончательным. В приведенном выше коде, если вы измените значение xво внутреннем классе, FirstLevelто компилятор выдаст вам сообщение об ошибке:

Локальные переменные, на которые ссылается лямбда-выражение, должны быть окончательными или эффективно конечными.

Если бы вы могли добавить finalмодификатор к локальной переменной, это было бы эффективно.

Лямбда-выражения могут получить доступ

• статические переменные,

• переменные экземпляра,

• эффективно окончательные параметры метода, и

• эффективно финальные локальные переменные.

Источник: OCP: Oracle Certified Professional Java SE 8 Programmer II Учебное пособие, Жанна Боярски, Скотт Селикофф

Дополнительно,

effectively finalПеременная является переменной, значение которой никогда не изменяется, но он не объявлен с finalключевым словом.

Источник: Начиная с Java: от структур управления до объектов (6-е издание), Тони Гаддис

Кроме того, не забывайте о finalтом, что он инициализируется ровно один раз перед первым использованием.

Объявление переменной finalили не объявление ее final, но ее эффективное сохранение в конечном итоге может привести (зависит от компилятора) к другому байт-коду.

Давайте посмотрим на небольшой пример:

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

Соответствующий байт-код mainметода (Java 8u161 в 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

Соответствующая таблица номеров строк:

 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

Как мы видим , исходный код на линиях 12, 13, 14не отображается в байт - код. Это потому что iесть trueи не изменит его состояние. Таким образом, этот код недоступен (больше в этом ответе ). По той же причине код в строке 9тоже отсутствует. Состояние iне нужно оценивать, так как оно trueточно.

С другой стороны, хотя переменная jявляется окончательной, она не обрабатывается таким же образом. Таких оптимизаций не применено. Состояние jоценивается два раза. Байт-код один и тот же, независимо от того, jявляется ли он окончательным .

Окончательная переменная Effectively является локальной переменной, которая:

1. Не определено как final
2. Назначается ТОЛЬКО один раз.

В то время как финальная переменная является переменной, которая:

1. объявлено с finalключевым словом.

Однако, начиная с Java SE 8, локальный класс может обращаться к локальным переменным и параметрам> заключающего блока, которые являются окончательными или фактически конечными.

Это не началось на Java 8, я использую это с давних времен. Этот код используется (до Java 8), чтобы быть законным:

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