1.內部類訪問特點:

1.可以直接訪問外部類的私有成員.
2.外部類想要訪問內部類時,要在外面建立內部類的物件,進行呼叫.

1.2內部類什麼時候使用呢?

一般用於類的設計.

分析事物時,發現該事物描述中還有事物,
而且這個事物還在訪問被描述事物的內容,
這時就是還有的事物定義成內部類來描述.
例如:心臟要經常使用人體內部的其他器官,
所以心臟就是內部類,人就是外部類.

class Outer
{
    private static int num = 4;

    static class Inner
    {
        static void show()
        {
            System.out.println("show........"
 
+num);
        }
    }

    void method()
    {
        Inner in = new Inner();
        in.show();
    }
}

class innerClassDemo
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
        //直接訪問外部類中的內部類
        // Outer.Inner in = new Outer().new Inner();
 

        // in.show();
        //如果一個內部類是靜態的,那麼該類相當於一個外部類.
        Outer.Inner i = new Outer.Inner();
        i.show();
        //Outer.Inner.show();
    }
}

1.3為什麼內部類能直接訪問外部類中成員呢?

那是因為內部類持有了外部類的引用,  外部類名.this;

2.內部類可以存放在區域性位置上.

內部類在區域性位置上只能訪問區域性中被final修飾的區域性變數.

class Outer
{
    private int num = 2
 
;
    class Inner
    {
        private int num = 3;
        void show()
        {
            int num = 4;
            System.out.println(Outer.this.num);
        }
    }
    void method()
    {
        new Inner().show();
    }
    //區域性內部類
    void method2()
    {
        final int x = 1;

        class Inner2
        {
            void show()
            {
                System.out.println("show......."+x);
            }
        }

        new Inner2().show();
    }
}

class innerClassDemo3
{
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
        o.method2();
    }
}

3.匿名內部類:

有前提:
內部類必須繼承或者實現一個外部類或者介面.

匿名內部類:其實就是一個匿名子類物件.
格式: new 父類or介面() {子類內容}

abstract class Demo
{
    abstract void show();
}

class Outer
{
    int num = 4;
/*  class
    {
        void show()
        {
            System.out.println("show....."+num);
        }
    }
*/  
    public void method()
    {
        new Demo()
        {
            void show()
            {
                System.out.println("show........");
            }
            void haha()
            {
                System.out.println("hah........");
            }

        }.haha();
    }
}

class innerClassDemo4
{
    public static void main (String[] args)
    {
        new Outer().method();
    }
}

3.2 應用例子

interface Inter
{
    public abstract void show1();
    public abstract void show2();
}

class Outer
{
/*  class Inner implements Inter
    {
        public void show1()
        {
            System.out.println("haha");
        }
        public void show2()
        {
            System.out.println("haha");
        }
    }
*/  
    public void method()
    {
        // new Inner().show1();
        // new Inner().show2();

        Inter in = new Inter()
        {
            public void show1()
            {
                System.out.println("haha");
            }
            public void show2()
            {
                System.out.println("haha");
            }
        };
        in.show1();
        in.show2();
    }
}
/*
通常的使用場景之一:
當函式的引數是介面型別時,而且介面中的方法不超過三個.
可以用匿名內部類作為實際引數進行傳遞.

*/



class innerClassDemo5
{
    public static void main(String[] args)
    {
        show(new Inter(){

            public void show1()
            {
                System.out.println("haha");
            }
            public void show2()
            {
                System.out.println("haha");
            }   
        });
    }
    public static void show(Inter in)
    {
        in.show1();
        in.show2();
    }
}

3.3舉例

class Outer
{
/*  void method()
        {
            new Object(){
                void show()
                {
                    System.out.println("show run");
                }
        }.show();
        //這個編譯可以通過,因為直接呼叫的是子類物件
*/      
    void method()
    {
        Object obj = new Object(){
            void show()
            {
                System.out.println("show run");
            }
    };
        obj.show();//編譯時不能通過!
        //因為匿名內部類這個子類物件被向上轉型為了Object型別.
        //這樣就不能使用子類特有的方法了
    }
}

class innerClassDemo6
{

    public static void main(String[] args)
    {
        new Outer().method();

    }
}

4.類的初始化過程

class Father
{
    {
        System.out.println("father construction block");
    }
    Father()
    {
        super();//object
        //顯示初始化
        //構造程式碼塊初始化
        System.out.println("father constructor ");
        show();
    }
    void show()
    {
        System.out.println("haha");
    }
}

class Kid extends Father
{
    int num = 8;//預設初始化 num = 0;
    {
        num = 9;
        System.out.println("Kid construction block");
    }
    Kid()
    {
        super();//Father
        //顯示初始化
        //構造程式碼塊初始化
        System.out.println("Kid constructor");
        show();
    }
    void show()
    {
        System.out.println("show......."+num);

    }
}

class intiProcess
{
    public static void main(String[] args)
    {
        new Kid();
    }
}

執行結果

綜上可得:先預設初始化->通過super()跳到父類->父類預設初始化->父類建構函式塊初始化->父類建構函式初始化->子類顯示初始化->子類建構函式塊初始化->子類建構函式初始化