Java 高級開發必修知識---內部類

Java 內部類分為： 1）成員內部類 2）靜態嵌套類 3）方法內部類 4）匿名內部類內部類的共性 1、內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號。 2、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪 ...

Java 內部類分為：

　　1）成員內部類

　　2）靜態嵌套類

　　3）方法內部類

　　4）匿名內部類

內部類的共性

1、內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號。

2、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。

3、內部類聲明成靜態的，就不能隨便的訪問外部類的成員變數了，此時內部類只能訪問外部類的靜態成員變數。

成員內部類

成員內部類就是將類放在類中

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        成員內部類
 */

public class Member1 {
    class Inner {
    }
}

編譯上述代碼會產生兩個文件：Member.class和Member$Inner.class。

方法內部類

把類放在方法內

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        方法內部類
 */

public class Member2 {
    public void doSomething() {
        class Inner {
            public void seeOuter() {
            }
        }
    }

}

(1)、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。

(2)、方法內部類對象不能使用該內部類所在方法的非final局部變數。

因為方法的局部變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變數成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變數內。正因為不能保證局部變數的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。

完整慄子：

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        方法內部類 實例
 */

public class Member3 {
    public void doSomething() {
        final int a = 10;
        class Inner {
            public void seeOuter() {
                System.out.println(a);
            }
        }
        Inner in = new Inner();
        in.seeOuter();
    }

    public static void main(String[] args) {
        Member3 out = new Member3();
        out.doSomething();
    }

}

匿名內部類

顧名思義，沒有名字的內部類。錶面上看起來它們似乎有名字，實際那不是它們的名字。

當程式中使用匿名內部類時，在定義匿名內部類的地方往往直接創建該類的一個對象。匿名內部類的聲明格式如下：

new ParentName（）{
...// 內部類的定義
}

匿名內部類就是沒有名字的內部類。什麼情況下需要使用匿名內部類？如果滿足下麵的一些條件，使用匿名內部類是比較合適的：

·只用到類的一個實例。

·類在定義後馬上用到。

·類非常小（SUN推薦是在4行代碼以下）

·給類命名並不會導致你的代碼更容易被理解。

在使用匿名內部類時，要記住以下幾個原則：

·匿名內部類不能有構造方法。

·匿名內部類不能定義任何靜態成員、靜態方法。

·匿名內部類不能是public,protected,private,static。

·只能創建匿名內部類的一個實例。

·一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類。

·因匿名內部類為局部內部類，所以局部內部類的所有限制都對其生效。

A、繼承式的匿名內部類

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *
 *        繼承式匿名內部類
 */

public class Member4 {

    public void drive() {
        System.out.println("Driving a car!");
    }

    public static void main(String[] args) {
        Member4 car = new Member4() {
            public void drive() {
                System.out.println("Driving another car!");
            }
        };
        car.drive();
    }

}

結果輸出了：Driving another car! Car引用變數不是引用Car對象，而是Car匿名子類的對象。

B、介面式的匿名內部類。

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        介面式匿名內部類
 */

public class Member5 {
    public static void main(String[] args) {
        Vehicle v = new Vehicle() {
            public void drive() {
                System.out.println("Driving a car!");
            }
        };
        v.drive();
    }
}

interface Vehicle {
    public void drive();
}

上面的代碼很怪，好像是在實例化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面

C、參數式的匿名內部類。

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        參數式匿名內部類
 */

public class Member6 {
    static void go() {
        Bar b = new Bar();
        b.doStuff(new Foo() {
            public void foo() {
                System.out.println("foofy");
            }
        });
    }

}

interface Foo {
    void foo();
}

class Bar {
    void doStuff(Foo f) {
        f.foo();
    }
}

靜態嵌套類

靜態內部類中可以定義靜態或者非靜態的成員。

從技術上講，靜態嵌套類不屬於內部類。因為內部類與外部類共用一種特殊關係，更確切地說是對實例的共用關係。而靜態嵌套類則沒有上述關係。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。

靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它。靜態嵌套類僅能訪問外部類的靜態成員和方法。

package cn.internal;

/**
 * 
 * @author: 房上的貓
 * 
 * @time: 下午9:08:33
 * 
 * @博客地址: https://www.cnblogs.com/lsy131479/
 *
 *        靜態嵌套內部類
 */

public class Member7 {
    static class Inner {
    }
}

class Test {
    public static void main(String[] args) {
        Member7.Inner n = new Member7.Inner();
    }

}

在靜態方法中定義的內部類也是StaticNested Class，這時候不能在類前面加static關鍵字，靜態方法中的StaticNested Class與普通方法中的內部類的應用方式很相似，它除了可以直接訪問外部類中的static的成員變數，還可以訪問靜態方法中的局部變數，但是，該局部變數前必須加final修飾符。

為什麼需要內部類？

典型的情況是，內部類繼承自某個類或實現某個介面，內部類的代碼操作創建其他外圍類的對象。所以你可以認為內部類提供了某種進入其外圍類的視窗。使用內部類最吸引人的原因是：

每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。如果沒有內部類提供的可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效地實現了“多重繼承”。