Java詳解匿名内部類

一、使用匿名内部類内部類

匿名内部類由于沒有名字，是以它的建立方式有點兒奇怪。建立格式如下：

new 父類構造器（參數清單）|實作接口（）  
    {  
     //匿名内部類的類體部分      

在這裡我們看到使用匿名内部類我們必須要繼承一個父類或者實作一個接口，當然也僅能隻繼承一個父類或者實作一個接口。同時它也是沒有class關鍵字，這是因為匿名内部類是直接使用new來生成一個對象的引用。當然這個引用是隐式的。

public abstract class Bird {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public abstract int fly();
}

public class Test {
    
    public void test(Bird bird){
        System.out.println(bird.getName() + "能夠飛 " + bird.fly() + "米");
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        test.test(new Bird() {
            
            public int fly() {
                return 10000;
            }
            
            public String getName() {
                return "大雁";
            }
        });
    }
}
------------------
Output：
大雁能夠飛 10000米      

在Test類中，test()方法接受一個Bird類型的參數，同時我們知道一個抽象類是沒有辦法直接new的，我們必須要先有實作類才能new出來它的實作類執行個體。是以在mian方法中直接使用匿名内部類來建立一個Bird執行個體。

     由于匿名内部類不能是抽象類，是以它必須要實作它的抽象父類或者接口裡面所有的抽象方法。

      對于這段匿名内部類代碼其實是可以拆分為如下形式：

public class WildGoose extends Bird{
    public int fly() {
        return 10000;
    }
    
    public String getName() {
        return "大雁";
    }
}

WildGoose wildGoose = new WildGoose();
test.test(wildGoose);      

在這裡系統會建立一個繼承自Bird類的匿名類的對象，該對象轉型為對Bird類型的引用。

      對于匿名内部類的使用它是存在一個缺陷的，就是它僅能被使用一次，建立匿名内部類時它會立即建立一個該類的執行個體，該類的定義會立即消失，是以匿名内部類是不能夠被重複使用。對于上面的執行個體，如果我們需要對test()方法裡面内部類進行多次使用，建議重新定義類，而不是使用匿名内部類。

二、注意事項

      在使用匿名内部類的過程中，我們需要注意如下幾點：

  1、使用匿名内部類時，我們必須是繼承一個類或者實作一個接口，但是兩者不可兼得，同時也隻能繼承一個類或者實作一個接口。

2、匿名内部類中是不能定義構造函數的。

3、匿名内部類中不能存在任何的靜态成員變量和靜态方法。

4、匿名内部類為局部内部類，是以局部内部類的所有限制同樣對匿名内部類生效。

5、匿名内部類不能是抽象的，它必須要實作繼承的類或者實作的接口的所有抽象方法。

三、使用的形參為何要為final

      參考檔案：​​http://android.blog.51cto.com/268543/384844​​

當所在的方法的形參需要被内部類裡面使用時，該形參必須為final。

      為什麼必須要為final呢？

      首先我們知道在内部類編譯成功後，它會産生一個class檔案，該class檔案與外部類并不是同一class檔案，僅僅隻保留對外部類的引用。當外部類傳入的參數需要被内部類調用時，從java程式的角度來看是直接被調用：

public class OuterClass {
    public void display(final String name,String age){
        class InnerClass{
            void display(){
                System.out.println(name);
            }
        }
    }
}      

      從上面代碼中看好像name參數應該是被内部類直接調用？其實不然，在java編譯之後實際的操作如下：

public class OuterClass$InnerClass {
    public InnerClass(String name,String age){
        this.InnerClass$name = name;
        this.InnerClass$age = age;
    }
    
    
    public void display(){
        System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
    }
}      

      是以從上面代碼來看，内部類并不是直接調用方法傳遞的參數，而是利用自身的構造器對傳入的參數進行備份，自己内部方法調用的實際上時自己的屬性而不是外部方法傳遞進來的參數。

      直到這裡還沒有解釋為什麼是final？在内部類中的屬性和外部方法的參數兩者從外表上看是同一個東西，但實際上卻不是，是以他們兩者是可以任意變化的，也就是說在内部類中我對屬性的改變并不會影響到外部的形參，而然這從程式員的角度來看這是不可行的，畢竟站在程式的角度來看這兩個根本就是同一個，如果内部類該變了，而外部方法的形參卻沒有改變這是難以了解和不可接受的，是以為了保持參數的一緻性，就規定使用final來避免形參的不改變。

簡單了解就是，拷貝引用，為了避免引用值發生改變，例如被外部類的方法修改等，而導緻内部類得到的值不一緻，于是用final來讓該引用不可改變。

      故如果定義了一個匿名内部類，并且希望它使用一個其外部定義的參數，那麼編譯器會要求該參數引用是final的。

四、匿名内部類初始化

public class OutClass {
    public InnerClass getInnerClass(final int age,final String name){
        return new InnerClass() {
            int age_ ;
            String name_;
            //構造代碼塊完成初始化工作
            {
                if(0 < age && age < 200){
                    age_ = age;
                    name_ = name;
                }
            }
            public String getName() {
                return name_;
            }
            
            public int getAge() {
                return age_;
            }
        };
    }
    
    public static void main(String[] args) {
        OutClass out = new OutClass();
        
        InnerClass inner_1 = out.getInnerClass(201, "chenssy");
        System.out.println(inner_1.getName());
        
        InnerClass inner_2 = out.getInnerClass(23, "chenssy");
        System.out.println(inner_2.getName());
    }
}