Різниця між остаточним та фактично остаточним

Я граю з лямбдами на 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;
    }
}

"Ефективно остаточний" - це змінна, яка не дала б помилки компілятора, якби вона була додана "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 .

Коли лямбда-вираз використовує призначену локальну змінну зі свого оточуючого простору, існує важливе обмеження. Вираз лямбда може використовувати лише локальну змінну, значення якої не змінюється. Це обмеження називається " змінним захопленням ", яке описується як; значення захоплення вираження лямбда, а не змінні .
Локальні змінні, які може використовувати лямбда-вираз, відомі як " ефективно остаточні ".
Ефективно остаточна змінна - це значення, значення якої не змінюється після її першого призначення. Не потрібно чітко заявляти таку змінну як остаточну, хоча це не буде помилкою.
Подивимось це на прикладі, у нас є локальна змінна 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 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 Посібник з вивчення програміста, Жанна Боярський, Скотт Селікофф

Крім того,

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 біт):

  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того, чи є фактично остаточним .

Ефективно остаточна змінна - це локальна змінна, яка:

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