【java開發系列】—— 嵌套類與内部類

嵌套類與内部類在java中使用的很廣泛，為了避免難以了解，這裡用了幾個小例子，說明它的用法。

　　嵌套類與内部類的結構如下圖

　　靜态嵌套類　　

　　靜态嵌套類，是一種在類之外聲明的嵌套類，由于是靜态的，是以不經過初始化，就可以通過類名，直接調用。

1 class out1{
2     private static String name = "xingoo";
3     static class info{
4         void print(){
5             System.out.println("name："+name);
6         }
7     }
8 }      

　　使用樣例

package testClass;
class out1{
    private static String name = "xingoo";
    static class info{
        void print(){
            System.out.println("name："+name);
        }
    }
}
class out2{
    private static String name = "xingoo test 2";
    static class info{
        String name = "inner infomation!";
        void printInner(){
            System.out.println("name:"+name);
        }
        void printOuter(){
            System.out.println("name:"+out2.name);
        }
    }
}
/**
 * 靜态嵌套類
 * @author xingoo
 *
 */
public class test1 {
    public static void main(String[] args){
        //建立對象時，以xxx.yyy這種格式建立
        out1.info oi = new out1.info();
        oi.print();

        out2.info oi2 = new out2.info();
        oi2.printInner();
        oi2.printOuter();
    }
}      

View Code

　　成員内部類

　　成員内部類，即該類作為另一個類的成員，是以隻有引用另一個類，才能建立這個類。

1 class outer{
2     private String name = "xingoo";
3     class inner{
4         void print(){
5             System.out.println(name);
6         }
7     }
8 }      

　　通常也用于隐藏的實作某個接口，如下面所示，第一種是傳統的實作方式，第二種是隐藏了實作接口的實作方式。

1 interface Printer{
 2     void print(String name);
 3 }
 4 class outerImpl1 implements Printer{
 5     @Override
 6     public void print(String name) {
 7         System.out.println(name);
 8     }
 9 }
10 class outerImpl2{
11     private class inner implements Printer{
12         @Override
13         public void print(String name) {
14             System.out.println(name);
15         }
16     }
17     public Printer getPrinter(){
18         return new inner();
19     }
20 }      

package testClass;
/**
 * 簡單測試成員内部類
 * @author xingoo
 *
 */
class outer{
    private String name = "xingoo";
    class inner{
        void print(){
            System.out.println(name);
        }
    }
}
interface Printer{
    void print(String name);
}
class outerImpl1 implements Printer{
    @Override
    public void print(String name) {
        System.out.println(name);
    }
}
class outerImpl2{
    private class inner implements Printer{
        @Override
        public void print(String name) {
            System.out.println(name);
        }
    }
    public Printer getPrinter(){
        return new inner();
    }
}
/**
 * 成員内部類
 * @author xingoo
 *
 */
public class test2 {
    public static void main(String[] args){
        //建立一個外部類的對象，通過調用這個對象的new方法建立其内部類的對象
        outer o = new outer();
        outer.inner i = o.new inner();
        i.print();


        //内部類實作接口隐藏
        Printer out1 = new outerImpl1();
        out1.print("xingoo test1");
        outerImpl1 out1trans = (outerImpl1)out1;//支援向下轉換

        Printer out2 = (new outerImpl2()).getPrinter();
        out2.print("xingoo test2");
        //無法向下轉換，因為inner是private類型的，這樣就實作了接口的隐藏
    }
}      

　　局部内部類

　　局部類的聲明之作用與某個代碼塊内，是以如果某個聲明的類僅僅被一段程式所使用，其他地方再也用不到，就可以用這種實作方式。·

1 interface Logger{
 2     public void log(String message);
 3 }
 4 public class test3 {
 5     
 6     String startTime = (new Date()).toString();
 7     /**
 8      * 局部内部類，從定義上來講，不屬于任何其他的類，因為是聲明在這個類内部的。與匿名内部類不同的就是它有名字。
 9      * @return
10      */
11     public Logger getLogger(){
12         //由于LoggerImpl隻在 getLogger内部使用，是以把它定義在函數内部，相對來說更安全一些
13         class LoggerImpl implements Logger{
14             @Override
15             public void log(String message) {
16                 System.out.println(startTime + ":" + message);
17             }
18         }
19         return new LoggerImpl();
20     }
21     
22     public static void main(String[] args){
23         test3 test = new test3();
24         Logger logger = test.getLogger();
25         logger.log("hello xingoo!");
26     }
27 }      

　　匿名内部類

　　在使用new建立對象時，直接在後面建立它的實作類。

1 abstract class Printable{
 2     public void print(String name){
 3         
 4     }
 5 }
 6 /**
 7  * 就是跟在new建立對象之後，直接定義它的類實作
 8  * @author Administrator
 9  */
10 public class test4 {
11     public static void main(String[] args){
12         Printable printer = new Printable(){
13             public void print(String name){
14                 System.out.println(name);
15             }
16         };//注意因為這其實是一個new文法，是以要加上分号;
17         printer.print("hello!xingoo!");
18     }
19 }      

參考資料：《JAVA 7程式設計》