寫在前面

匿名內部類來自外部閉包環境的自由變數必須是final的，除非自由變數來自類的成員變數。

什麼是自由變數？
一個函式的“自由變數”就是既不是函式引數也不是函式內部區域性變數的變數。

什麼是外部環境
外部環境如果持有內部函式所使用的自由變數，就會對內部函式形成“閉包”。

-

一個簡單的列子

public class AnonymousDemo1
{
    public static void main(String args[])
    {
        new AnonymousDemo1().play();
    }

    private
 
 void play()
    {
        Dog dog = new Dog();
        Runnable runnable = new Runnable()
        {
            public void run()
            {
                while(dog.getAge()<100)
                {
                    // 過生日，年齡加一
                    dog.happyBirthday();
                    // 列印年齡
 

                    System.out.println(dog.getAge());
                }
            }
        };
        new Thread(runnable).start();

        // do other thing below when dog's age is increasing
        // ....
    }
}

public class Dog
{
    private int age;

    public int getAge()
    {
        return
 
 age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public void happyBirthday()
    {
        this.age++;
    }
}

編譯上面的程式碼，編譯出錯

Variable ‘dog’ is accessed from within inner class，need to be declared final

意思說，需要將 dog 變數定義為 final 型別，可是為什麼要定義為 final 型別，final 型別的 變數有什麼優勢呢？

  final Dog dog = new Dog();

一個被final修飾的變數：
如果這個變數是基本資料型別，那麼它的值不能改變；

暫且先放一下上面的疑問，看看匿名內部類到底長什麼樣子

反編譯匿名內部類

反編譯之後的內名內部類程式碼如下：

class AnonymousDemo1$1 implements Runnable {

    final Dog val$dog;
    final AnonymousDemo1 this$0;

    AnonymousDemo1$1(final_anonymousdemo1,Dog)
    {
        this$0 = final_anonymousdemo1;
        val$dog = Dog.this;
        super();
    }

    public void run()
    {
        for(; val$dog.getAge() < 100; System.out.println(val$dog.getAge()))
            val$dog.happyBirthday();

    } 
}

1 匿名內部類的建構函式，有兩個引數：一個是外部類物件的引用，一個是區域性變數 Dog 物件的引用，因為下面的 run 方法會使用到該物件。
2 那麼 外部類 AnonymousDemo1 可以等同於如下的程式碼

public class AnonymousDemo1
{
    public static void main(String args[])
    {
        new AnonymousDemo1().play();
    }

    private void play()
    {
        Dog dog = new Dog();
        AnonymousDemo1$1 runnable = new AnonymousDemo1$1(this,dog)
        new Thread(runnable).start();
    }
}

還是沒有回答主要問題

到這裡我們已經看清匿名內部類的全貌了，其實Java就是把外部類的一個變數拷貝給了內部類裡面的另一個變數。這個例子中，無論是內部類的val$dog變數，還是外部類的dog變數,他們都只是一個儲存著物件例項地址的變數而已，而由於做了拷貝，這兩個變數指向的其實是同一只狗（物件）。

因此，這個例子中，假如我們不加上final，那麼我可以在程式碼後面加上這麼一句dog = new Dog(); 就像下面這樣：

// ...
new Thread(runnable).start();
// do other thing below when dog's age is increasing
dog = new Dog();

這樣，外面的dog變數就指向另一隻狗了，而內部類裡的val$dog，還是指向原先那一隻，就像這樣：

**這樣做導致的結果就是內部類裡的變數和外部環境的變數不同步，指向了不同的物件。
因此，編譯器才會要求我們給dog變數加上final，防止這種不同步情況的發生。**

那為什麼要拷貝呢

1 拷貝了什麼東西？
將 dog 的引用地址 拷貝到了 val$dog

2 為什麼要拷貝？
這時候就得考慮一下Java虛擬機器的執行時資料區域了，dog變數是位於方法內部的，因此dog是在虛擬機器棧上，也就意味著這個變數無法進行共享，匿名內部類也就無法直接訪問，因此只能通過值傳遞的方式，傳遞到匿名內部類中。

哪種情況不需要拷貝呢？

拷貝的原因，是因為 內部類中 無法 直接訪問外部方法中定義 的 dog 變數，如果可以直接訪問，那麼就沒必要拷貝 應用了

我們修改一下 AnonymousDemo1 程式碼，將 dog 變數提升為 成員屬性

private Dog dog = new Dog();

接下來反編譯一下 AnonymousDemo1$1 類

class AnonymousDemo1$1 implements Runnable
{

    final AnonymousDemo1 this$0;

    AnonymousDemo1$1()
    {
        this$0 = AnonymousDemo1.this;
        super();
    }

    public void run()
    {
        for(; AnonymousDemo1.access$000(AnonymousDemo1.this).getAge() < 100; System.out.println(AnonymousDemo1.access$000(AnonymousDemo1.this).getAge()))
            AnonymousDemo1.access$000(AnonymousDemo1.this).happyBirthday();

    }

}

1 現在 匿名內部類 不在需要 dog 變數的拷貝了，只需要引用 上層的 外部類物件就好了， 因為可以通過 外部類物件直接 獲取到 dog 物件了，因而編譯器也就不要求加上final了。

寫在最後

匿名內部類來自外部閉包環境的自由變數必須是final的”：

首先，自由變數是什麼？
一個函式的“自由變數”就是既不是函式引數也不是函式內部區域性變數的變數，這種變數一般處於函式執行時的上下文，就像demo中的dog，有可能第一次執行時，這個dog指向的是age是10的狗，但是到了第二次執行時，就是age是11的狗了。

然後，外部閉包環境是什麼？
外部環境如果持有內部函式所使用的自由變數，就會對內部函式形成“閉包”，demo1中，外部play方法中，持有了內部類中的dog變數，因此形成了閉包。
當然，demo2中，也可以理解為是一種閉包，如果這樣理解，那麼這句經典的話就應該改為這樣更為準確：
匿名內部類來自外部閉包環境的自由變數必須是final的，除非自由變數來自類的成員變數，僅針對 Java 語言 而言。