內部類分類介紹JAVA224-225

來源：http://www.bjsxt.com/
一、S03E224_01內部類分類介紹_靜態內部類詳解、成員內部類詳解

1、內部類介紹

package com.test.nestedclass;
/**
 * 測試內部類的基本定義方式
 */
public class Demo01 {
    //靜態內部類
    private static class StaticNestedClass{
    }

    //普通內部類(成員內部類)
    private class FieldInnerClass{
    }

    void sayHello(){
        //方法內部類(局部內部類)
        class LocalClass{
        }

        //匿名內部類。放到方法外面也可以，只是類型不一樣了(不同位置不同類型)。
        Runnable runnable = new Runnable() {//兩個作用：定義了匿名內部類的類體；創建了匿名內部類的一個實例！
            @Override
            public void run() {
            }
        };
    }
}

2、靜態內部類

package com.test.nestedclass;

import com.test.nestedclass.Outer02.StaticInnerClass;
/**
 * 測試靜態內部類的詳細用法
 */
public class Demo02{
    public static void main(String[] args) {
        //這樣寫比較明顯，看得出外部類
        Outer02.StaticInnerClass osic = new Outer02.StaticInnerClass();

        //在不相關類(Demo02)中，可直接創建靜態內部類的對象(不需要通過所在外部類(Outer02))
//      StaticInnerClass osic2 = new StaticInnerClass();//import com.test.nestedclass.Outer02.StaticInnerClass;
    }
}

class Outer02 {
    int c = 5;
    static int d = 10;

    void t1(){
        StaticInnerClass sic = new StaticInnerClass();
    }
    //靜態內部類
    /*private*/ static class StaticInnerClass {
        int a = 3;
        static int b = 5;//可包含靜態成員、非靜態成員

        public void test(){
            System.out.println(d);
//          System.out.println(c);//靜態內部類中不能調用外部類的普通成員！只能調用靜態成員！
        }
    }
}

3、成員內部類(普通內部類)

package com.test.nestedclass;
/**
 * 測試成員內部類的詳細用法
 */
public class Demo03 {
    public static void main(String[] args) {
        Outer03 out = new Outer03();
        Outer03.InnerClass ic = out.new InnerClass();//先有外部類對象，纔可創建內部類對象
        ic.test();
    }
}

class Outer03{
    private int a = 3;
    int b = 10;

    public void t1(){
        InnerClass ic = new InnerClass();//方法內可直接創建內部類對象
    }
    //成員內部類，相當於外部類的成員變量，可訪問外部類的所有成員
    class InnerClass{
        int c = 1;
        //成員內部類不能有靜態成員，除非聲明爲final，並且只能是編譯器可以確定值的常量表達式
        final static int d = 80;
//      final static Date d2 = new Date();

        //如果成員內部類可以有靜態成員，如下：
//      static InnerClass ab = new InnerClass();
        //則Outer03.InnerClass.ab可以直接獲取內部類對象，這時成員內部類對象就完全脫離了外部類的控制！與設計成員內部類的初衷完全不一致！

        void test(){
            System.out.println(a);
            //方法內
            System.out.println("內部類對象：" + this);//成員內部類對象的創建。必須先有外部類對象！
            System.out.println("外部類對象：" + Outer03.this);//引用了外部類的對象！
        }
    }
}

二、S03E225_01方法內部類_final修飾局部變量問題、匿名內部類(繼承式和接口式和參數式)

1、方法內部類(局部內部類)

package com.test.nestedclass;
/**
 * 測試方法內部類(局部內部類)
 */
public class Demo04 {
    public static void main(String[] args) {
    }
}

class Outer04{

    public void test(){
        /*final*/ int a = 3;

        class Inner{
            int b = 10;
//      static int c = 20;//方法內部類中只能定義非靜態成員

            void t1(){
                System.out.println(b);
//              System.out.println(a);
                //方法內部類中不能引用所在方法的普通局部變量，除非是常量。原因如下：
                //方法的生命週期和方法內部類對象的生命週期不一致！方法執行完，內部類對象可能仍然存在！
            }
        }
    }
}

2、匿名內部類

package com.test.nestedclass;
/**
 * 測試匿名內部類
 */
public class Demo05 {
    public static void main(String[] args) {
        Outer05 outer = new Outer05();
        outer.test();
    }
}

class Outer05{
    public void test02(Car car){
        car.run();
    }

    public void test(){
        final int a = 3;
        //匿名內部類(接口式)，由於本內部類定義在方法中，也是方法內部類
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
            }
        };

        //匿名內部類，繼承式
        Car car = new Car(){
            @Override
            public void run() {
                System.out.println("子類的車跑！");
                System.out.println(a);
            }
        };
        car.run();

        test02(new Car(){
            @Override
            public void run() {
                System.out.println("參數式匿名內部類，車在跑！");
            }
        });
    }
}

class Car{
    public void run(){ 
        System.out.println("汽車跑！");
    }
}