java物件導向（5）

object 類：

Object:是所有物件的直接後者間接父類，傳說中的上帝。
該類中定義的肯定是所有物件都具備的功能。

Object類中已經提供了對物件是否相同的比較方法。
如果自定義類中也有比較相同的功能，沒有必要重新定義。
只要沿襲父類中的功能，建立自己特有比較內容即可。這就是覆蓋。

內部類

當描述事物時，事物的內部還有事物，該事物用內部類來描述。因為內部事物在使用外部事物的內容

內部類的訪問規則：
1，內部類可以直接訪問外部類中的成員，包括私有。
    之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的引用，格式 外部類名.this
2，外部類要訪問內部類，必須建立內部類物件。

訪問格式：

1,當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。
可以直接建立內部類物件。
格式
    外部類名.內部類名  變數名 = 外部類物件.內部類物件;
    Outer.Inner in = new Outer().new Inner();
2,當內部類在成員位置上，就可以被成員修飾符所修飾。
    比如，private：將內部類在外部類中進行封裝。
        static:內部類就具備static的特性。
        當內部類被static修飾後，只能直接訪問外部類中的static成員。出現了訪問侷限。
        在外部其他類中，如何直接訪問static內部類的非靜態成員呢？
        new Outer.Inner().function();
        在外部其他類中，如何直接訪問static內部類的靜態成員呢？
        uter.Inner.function();
    注意：當內部類中定義了靜態成員，該內部類必須是static的。
          當外部類中的靜態方法訪問內部類時，內部類也必須是static的。

內部類定義在區域性時，
1，不可以被成員修飾符修飾
2，可以直接訪問外部類中的成員，因為還持有外部類中的引用。
    但是不可以訪問它所在的區域性中的變數。只能訪問被final修飾的區域性變數。

---

class Outer
{
    private static  int x = 3;    
    static class Inner//靜態內部類
    {
        static void function()
        {
            System.out.println("innner :"+x);
        }
    }
    static class Inner2
    {
        void show()
        {
            System.out.println("inner2 show");
        }
    }
    public static void method()
    {
        //Inner.function();
        new Inner2().show();
    }
}
class  InnerClassDemo2
{
    public static void main(String[] args)
    {
        Outer.method();
        Outer.Inner.function();
        new Outer.Inner().function();
    }
}

---

class Outer
{
    int x = 3;
    void method(final int a)
    {
final int y = 4;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }   
        new Inner().function();
    }
}
class  InnerClassDemo3
{
    public static void main(String[] args)
    {
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }
}

---

匿名內部類:
1，匿名內部類其實就是內部類的簡寫格式。
2，定義匿名內部類的前提：
    內部類必須是繼承一個類或者實現介面。
3，匿名內部類的格式：  new 父類或者介面(){定義子類的內容}
4，其實匿名內部類就是一個匿名子類物件。而且這個物件有點胖。    可以理解為帶內容的物件。
5，匿名內部類中定義的方法最好不要超過3個。

---

abstract class AbsDemo
{
    abstract void show();
}
class Outer
{
    int x = 3;
    /*
    class Inner extends AbsDemo
    {
        int num = 90;
        void show()
        {
            System.out.println("show :"+num);
        }
        void abc()
        {
            System.out.println("hehe");
        }
    }
    */
    public void function()
    {
        //AbsDemo a = new Inner();
//        Inner in = new Inner();
//        in.show();
//        in.abc();
        new AbsDemo()
        {
            int num = 9;
            void show()
            {
                System.out.println("num==="+num);
            }
            void abc()
            {
                System.out.println("haha");
            }
        }.show();
        new AbsDemo()
        {
            int num = 9;
            void show()
            {
                System.out.println("num==="+num);
            }
            void abc()
            {
                System.out.println("haha");
            }
        }.abc();
        AbsDemo d=new AbsDemo()
        {
            int num = 9;
            void show()
            {
                System.out.println("num==="+num);
            }
            void abc()
            {
                System.out.println("haha");
            }
        };
        d.show();
        //d.abc();//編譯失敗;
    }
}
class ExtendsDemo3
{
    public static void main(String[] args)
    {
        new Outer().function();
    }
}

---

interface Inter
{
    void method();
}
class Test
{
    //補足程式碼。透過匿名內部類。
    /*
    static class Inner implements Inter
    {
        public void method()
        {
            System.out.println("method run");
        }
    }
    */
    static Inter function()
    {
        return new Inter()
        {
            public void method()
            {
                System.out.println("method run");
            }
        };
    }
}
class InnerClassTest
{
    public static void main(String[] args)
    {
        //Test.function():Test類中有一個靜態的方法function。
        //.method():function這個方法運算後的結果是一個物件。而且是一個Inter型別的物件。
        //因為只有是Inter型別的物件，才可以呼叫method方法。
        Test.function().method();
//        Inter in = Test.function();
//        in.method();
    }
}