Java內部類使用總結

1.什麼是內部類?
　　定義在類內部的類,稱之為內部類

 public class Out{
 　　class In{    //此時In就是內部類
 　　}    
}

2.為什麼要使用內部類?
　　1),增強封裝,把內部類隱藏在外部類中,不允許其他類來訪問內部類
　　2),內部類能提高代碼的可讀性和可維護性

3.內部類的分類
　　對於內部類的分類,可以對比於成員變量的分類.
　　我們可以根據不同的修飾符或者定義的不同位置把成員變量,可以細分為:類成員變量,實例成員變量,局部變量.
　　內部類看做是外部類的一個成員,那麼內部類可以使用public/缺省/protected/private修飾.還可以是static修飾.
　　同理,內部類也根據使用不同的修飾符或者定義的不同位置,將其分成4類:

　　1),實例內部類:內部類沒有使用static修飾
　　2),靜態內部類:內部類使用static修飾
　　3),局部內部類:在方法中定義的內部類
　　4),匿名內部類:只能使用一次,屬於內部類的一種特殊情況

3.1實例內部類:
　　1)定義:實例內部類,即沒有使用static修飾的內部類.這說明,實例內部類屬於外部類的對象,不屬於外部類本身(類比字段).
　　2)創建實例內部類

//外部類
class Outter {
    // 實例內部類:沒有使用static修飾
    class Inner {

    }
}

public class InnerDemo1 {
    public static void main(String[] args) {
        // 創建實例內部類,沒有使用static修飾,屬於外部類的對象,因此,創建實例內部類前,必須存在外部類對象
        Outter out = new Outter();
        // 通過外部類對象創建內部類對象
        Outter.Inner in = out.new Inner();
    }
}

　　3)特點:

　　　　a.由創建實例內部類的過程可知,當存在內部類對象時,一定存在外部類對象.

　　　　b.實例內部類的實例自動持有外部類的實例的引用,實例內部類可以無條件訪問外部類的所有字段和方法

　　　　注意:當成員內部類擁有和外部類同名的成員變量或者方法時，會發生隱藏現象

　　　　c.外部類中不能直接訪問內部類的成員,必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問

//外部類
class Outter {
    private String name = "out";
    private Integer age = 17;

    // 實例內部類:沒有使用static修飾
    class Inner {
        private Integer age = 18; // 隱藏現象,隱藏了外部類的age

        Inner() {
            // 特點:1.實例內部類能直接訪問外部類成員
            // 2.當實例內部類和外部類有同名的字段或者方法時，會發生隱藏現象
            System.out.println(name + this.age);// 輸出out18
            // 此時若需要使用外部類的age,語法:外部類.this.age
            System.out.println(Outter.this.age);// 輸出17
        }
    }
}

總結:簡單來說,就是看變量的作用域,外部類成員變量的作用域是整個外部類,而內部類在外部類中(可以看做外部類的字段),內部類自然就可以訪問外部類.而外部類要去訪問內部類的成員,可以這樣理解:內部類的成員屬於內部類,在內部類中有效,內部類都不存在,其中的成員變量也不會存在,所以,外部類中不能直接訪問內部類的成員,必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問.

3.2靜態內部類

　　1)定義:使用static修飾的內部類.所以,該內部類屬於外部類本身,而不屬於外部類的對象

　　2)創建靜態內部類

//外部類
class Outter {
    // 靜態內部類:使用static修飾
    static class Inner {
    }
}

public class InnerDemo2 {
    public static void main(String[] args) {
        // 因為靜態內部類屬於外部類本身,可以直接通過外部類類名來訪問(類比字段)
        Outter.Inner in = new Outter.Inner();
    }
}

　　3)特點:

　　　　a.在創建內部類的實例時,不必創建外部類的實例.

　　　　b.靜態內部類可以直接訪問外部類的靜態成員,如果訪問外部類的實例成員,必須通過外部類的實例去訪問.

　　　　　　簡單理解:靜態成員屬於類,非靜態成員屬於對象,如果要訪問外部類的實例成員(非靜態成員),當然要先存著外部類對象的.而靜態內部類的創建是不需要外部類的對象,因此,如果訪問外部類的實例成員,必須通過外部類的實例去訪問.

　　　　c.在靜態內部類中可以定義靜態成員和實例成員.

　　　　d.測試類可以通過完整的類名直接訪問靜態內部類的靜態成員.

//外部類
class Outter {
    static String name = "outter";
    public Integer age = 17;

    // 靜態內部類:使用static修飾
    static class Inner {
        Inner() {
            // 靜態內部類能直接訪問外部類的靜態成員
            System.out.println(name);// 輸出 outter
            // 訪問外部類的實例成員,必須通過外部類的實例去訪問.
            System.out.println(new Outter().age);// 輸出 17
        }
    }
} 

3.3局部內部類(幾乎用不到)

　　1)定義:在方法中定義的內部類,其可見范圍是當前方法,和局部變量是同一個級別,所以局部內部類只能在方法中使用.

　　　　注意，局部內部類和方法裡面的局部變量一樣，是不能有public、protected、private以及static修飾符的。

public class InnerDemo3 {
    public static void main(String[] args) {
        // 局部內部類
        class Inner {
        }
    }
}

　　2)特點:

　　　　a.局部內部類和實例內部類一樣,不能包含靜態成員.(局部內部類屬於方法,而靜態成員屬於類)

　　　　b.局部內部類和實例內部類,可以訪問外部類的所有成員.

　　　　c.局部內部類訪問的局部變量必須使用final修飾,在Java8中是自動隱式加上final(語法糖).

　　　　　　原因:當方法被調用運行完畢之後,當前方法的棧幀被銷毀,方法內部的局部變量的空間全部銷毀.但內部類對象可能還在堆內存中,要直到沒有被引用時才會消亡.此時就會出現一種情況:內部類要訪問一個不存在的局部變量.為了避免該問題,我們使用final修飾局部變量,從而變成常量,永駐內存空間,即使方法銷毀之後,該局部變量也在內存中,對象可以繼續持有.

public class InnerDemo3 {
    public static void main(String[] args) {
        int age = 17;
        final int num = 15;
        // 局部內部類
        class Inner {
            public void test() {
                // 報錯:Cannot refer to a non-final variable age inside an inner class defined in a different method
                System.out.println(age);
                System.out.println(num);// 正確
            }
        }
    }
} 

3.4匿名內部類(使用最頻繁)

　　1):定義:匿名內部類是一個沒有名稱的局部內部類,適合於只使用一次的類.

　　2)創建匿名內部類:

匿名內部類本身沒有構造器,但是會調用父類構造器.一般來說,匿名內部類用於繼承其他類或是實現接口,並不需要增加額外的方法,只是對繼承方法的實現或是重寫.

注意：匿名內部類必須繼承一個父類或者實現一個接口,但最多只能一個父類或實現一個接口.

//定義一個接口
interface Person {
   public void eat();
}

public class AnonymousDemo {
   public static void main(String[] args) {
       // 使用匿名內部類
        Person p = new Person() {
           public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

4.總結

5.面試題public class Outer {
   public void someOuterMethod() {
       // Line 3
    }

   public class Inner {
    }

   public static void main(String[] argv) {
        Outer o= new Outer();
       // Line 8
    }
}

/*
* Which instantiates an instance of Inner?
A. new Inner(); // At line 3
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner();    // At line 8
*/

答案A.new Inner();等價於this.new Inner();已經存在一個Outer類對象了.

line 8 正確寫法,應為: o.new Inner();