Final ile efektif final arasındaki fark

Java 8'de lambdaslarla oynuyorum ve uyarı ile karşılaştım local variables referenced from a lambda expression must be final or effectively final. Anonim sınıf içindeki değişkenleri kullandığımda bunların dış sınıfta final olması gerektiğini biliyorum, ama yine de - final ile etkili final arasındaki fark nedir?

... Java SE 8'den başlayarak, yerel bir sınıf, son veya etkin bir şekilde nihai olan kapalı bloğun yerel değişkenlerine ve parametrelerine erişebilir. Başlatıldıktan sonra değeri hiçbir zaman değiştirilmeyen bir değişken veya parametre etkili bir şekilde kesindir.

Örneğin, değişkenin numberLengthnihai olarak bildirilmediğini ve işaretli atama deyimini yapıcıya eklediğinizi varsayalım 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;
     }

  ...

  }

...

}

Bu atama deyimi nedeniyle, numberLength değişkeni artık etkin bir şekilde son değil. Sonuç olarak, Java derleyicisi , iç sınıf PhoneNumber numberLength değişkenine erişmeye çalıştığında "iç sınıftan başvuruda bulunulan yerel değişkenler son ya da etkin bir şekilde son olmalıdır" benzeri bir hata iletisi oluşturur :

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

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

Ben "etkili nihai" açıklamak için en basit yolu finaldeğiştirici değişken bir bildirime eklemek hayal olduğunu bulmak . Bu değişiklikle birlikte, program hem derleme zamanında hem de çalışma zamanında aynı şekilde davranmaya devam ederse, bu değişken etkili bir şekilde kesindir.

Dokümanlara göre :

Başlatıldıktan sonra değeri hiçbir zaman değiştirilmeyen bir değişken veya parametre etkili bir şekilde kesindir.

Temel olarak, derleyici bir değişkenin başlatılmasının dışındaki atamalarda görünmediğini fark ederse, değişken etkili bir şekilde son olarak kabul edilir .

Örneğin, bir sınıf düşünün:

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

'Etkili final', 'final' eklenecekse derleyici hatası vermeyecek bir değişkendir

'Brian Goetz' tarafından yazılan bir makaleden,

Gayri resmi olarak, bir yerel değişken, başlangıç ​​değeri asla değişmezse etkili bir şekilde kesindir - başka bir deyişle, nihai olarak bildirilmesi derleme hatasına neden olmaz.

lambda-state-final- Brian Goetz

Aşağıdaki bu değişken kesindir , bu nedenle başlatıldıktan sonra değerini değiştiremeyiz. Eğer denersek bir derleme hatası alırız ...

final int variable = 123;

Ancak böyle bir değişken yaratırsak, değerini değiştirebiliriz ...

int variable = 123;
variable = 456;

Ama içinde Java 8 , bütün değişkenler nihai varsayılan olarak. Ancak koddaki 2. satırın varlığı onu sonlandırmaz . Yukarıdaki koddan 2. satırı kaldırırsak, değişkenimiz şimdi "etkin bir şekilde son" olur ...

int variable = 123;

Yani .. Bir kez ve sadece bir kez atanan herhangi bir değişken "etkin bir şekilde nihai" dir .

Bir değişken, bir kez başlatıldığında ve sahip sınıfında hiçbir zaman mutasyona uğratılmadığında nihai veya etkili bir şekilde nihai olur . Ve bunu döngülerde veya iç sınıflarda başlatamayız .

Final :

final int number;
number = 23;

Etkili Final :

int number;
number = 34;

Not : Nihai ve Etkili Nihai benzerdir (atama sonrasında değerleri değişmez), ancak sadece etkili Nihai değişkenler Anahtar Kelime ile bildirilmez final.

Bir lambda ifadesi, kapalı alanından atanmış bir yerel değişken kullandığında önemli bir kısıtlama vardır. Lambda ifadesi yalnızca değeri değişmeyen yerel değişkeni kullanabilir. Bu kısıtlamaya " değişken yakalama " denir ; lambda ifadesi değişkenleri değil değerleri yakalar .
Bir lambda ifadesinin kullanabileceği yerel değişkenler " etkin bir şekilde nihai " olarak bilinir .
Etkili bir son değişken, değeri ilk atandıktan sonra değişmeyen değişkendir. Böyle bir değişkeni kesin olarak kesin olarak bildirmeye gerek yoktur, ancak bunu yapmak bir hata olmaz.
Bir örnekle görelim, 7 değeriyle başlatılmış yerel bir i değişkenimiz var, lambda ifadesinde i'ye yeni bir değer atayarak bu değeri değiştirmeye çalışıyoruz. Bu derleyici hatası ile sonuçlanır - " Kapalı bir kapsamda tanımlanan yerel değişken i son veya etkin bir şekilde son olmalıdır "

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

Etkili nihai konu JLS 4.12.4'te açıklanmıştır ve son paragraf açık bir açıklama içermektedir:

Bir değişken etkili bir şekilde nihai ise, son değiştiriciyi bildirimine eklemek derleme zamanı hataları oluşturmaz. Buna karşılık, geçerli bir programda nihai olarak bildirilen bir yerel değişken veya parametre, son değiştirici kaldırıldığında etkili bir şekilde son haline gelir.

final , anahtar kelimeye sahip değişken bir deklarasyondur final, örnek:

final double pi = 3.14 ;

finalprogramın dışında kalır .

etkin bir şekilde son : şu anda yalnızca bir kez değer atanan (veya yalnızca bir kez güncellenen) herhangi bir yerel değişken veya parametre. Program boyunca etkili bir şekilde nihai kalamayabilir . bu da etkili bir şekilde son değişkenin, en az bir ödev daha atandığında / güncellendikten hemen sonra etkin bir şekilde nihai özelliğini kaybedebileceği anlamına gelir . misal:

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; 

        }
    }    
}

Diğerlerinin söylediği gibi, değeri başlatıldıktan sonra hiçbir zaman değiştirilmeyen bir değişken veya parametre etkili bir şekilde kesindir. Yukarıdaki kodda, xiç sınıftaki değerini değiştirirseniz FirstLevelderleyici size hata mesajı verir:

Lambda ifadesinden referans alınan yerel değişkenler nihai veya etkili bir şekilde nihai olmalıdır.

finalDeğiştiriciyi yerel bir değişkene ekleyebildiyseniz , etkili bir şekilde son halini aldı.

Lambda ifadeleri erişebilir

• statik değişkenler,

• örnek değişkenler,

• etkili bir şekilde nihai yöntem parametreleri ve

• etkili nihai yerel değişkenler.

Kaynak: OCP: Oracle Sertifikalı Profesyonel Java SE 8 Programcı II Çalışma Kılavuzu, Jeanne Boyarsky, Scott Selikoff

Bunlara ek olarak,

Bir effectively finaldeğişken, değeri hiç değişmedi bir değişkendir, ancak bildirilmez finalanahtar kelime.

Kaynak: Java ile Başlamak: Kontrol Yapılarından Nesnelere (6. Baskı), Tony Gaddis

Ayrıca, finalilk kez kullanılmadan önce tam olarak bir kez başlatılmasının anlamını unutmayın .

Bir değişkeni bildirmek finalveya bildirmemek final, ancak etkin bir şekilde nihai tutmak farklı bir bayt koduyla sonuçlanabilir (derleyiciye bağlıdır).

Küçük bir örneğe bakalım:

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

mainYöntemin karşılık gelen bayt kodu ( Windows 64 Bit'te Java 8u161):

  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

İlgili satır numarası tablosu:

 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

Biz çizgilerine kaynak kodunu görmek üzere 12, 13, 14bayt kodu görünmüyor. Çünkü iolduğunu trueve 's durumunu değiştirmeyecektir. Böylece bu koda ulaşılamaz (bu cevapta daha fazla ). Aynı nedenden dolayı satırdaki kod da 9özlüyor. Kesin iolduğu trueiçin durumunun değerlendirilmesi gerekmez .

Değişken olsa Öte yandan jise etkili bir nihai aynı şekilde işlenir değil. Uygulanan böyle bir optimizasyon yoktur. Durumu jiki kez ölçüldü. Bayt kodu, etkin bir şekilde nihaij olmasına bakılmaksızın aynıdır .

Etkili son değişken şu yerel bir değişkendir:

1. Olarak tanımlanmadı final
2. SADECE bir kez atandı.

Son değişken şu değişken:

1. bir finalanahtar kelime ile bildirildi .

Bununla birlikte, Java SE 8'den başlayarak, yerel bir sınıf, son veya etkin olarak nihai olan> kapalı bloğun yerel değişkenlerine ve parametrelerine erişebilir.

Bu Java 8'de başlamadı, bunu uzun zamandır kullanıyorum. Bu kod (java 8'den önce) yasal olarak kullanıldı:

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