黑馬程序員——面向對象篇之多態

------- android培訓、java培訓、期待與您交流！ ----------

多態

   定義：某一類事物的多種存在形態。

   例：動物中貓，狗。

   貓這個對象對應的類型是貓類型

   貓x = new 貓();

   同時貓也是動物中的一種，也可以把貓稱為動物。

1、多態的體現。

   父類的引用指向了自己的子類對象。

   父類的引用也可以接受自己的子類對象。

2、多態的前提。

   必須是類與類之間有關系，要么繼承，要么實現。

   通常還有個前提，存在覆蓋。

3、多態的利弊。

   利處：多態的出現大大的提高了程序的擴展性。

   弊端：只能使用父類的引用訪問父類中的成員。

4、多態的應用。

   示例代碼：

/*
需求：
電腦運行實例，電腦運行基于主板
*/
interface PCI
{
    public void open();
    public void close();
}
class MainBoard
{
    public void run()
    {
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p)//PCI p = new NetCard();接口型引用指向自己的子類對象。
    {
        p.open();
        p.close();
    }
}
class NetCard implements PCI
{
    public void open()
    {
        System.out.println("netcard open");
    }
    public void close()
    {
        System.out.println("netcard close");
    }
}
class SoundCard implements PCI
{
    public void open()
    {
        System.out.println("soundcard open");
    }
    public void close()
    {
        System.out.println("soundcard close");
    }
}
class  DuoTaiDemo5
{
    public static void main(String[] args)
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(new SoundCard());
    }
}

   如果想用子類對象的特有方法，如何判斷對象是哪個具體的子類類型呢？

       可以可以通過一個關鍵字 instanceof ;判斷對象是否實現了指定的接口或繼承了指定的類。

       格式：對象 instanceof 類型 ，判斷一個對象是否所屬于指定的類型。

       Studentinstanceof Person = true;//student繼承了person類

多態在子父類中的成員上的體現的特點：

   1，成員變量：在多態中，子父類成員變量同名。

       在編譯時期：參考的是引用型變量所屬的類中是否有調用的成員。（編譯時不產生對象，只檢查語法錯誤）

       運行時期：也是參考引用型變量所屬的類中是否有調用的成員。

       簡單一句話：無論編譯和運行，成員變量參考的都是引用變量所屬的類中的成員變量。

       再說的更容易記憶一些：成員變量 --- 編譯運行都看 = 左邊。

   2，成員函數。

       編譯時期：參考引用型變量所屬的類中是否有調用的方法。

       運行事情：參考的是對象所屬的類中是否有調用的方法。

       為什么是這樣的呢？因為在子父類中，對于一模一樣的成員函數，有一個特性：覆蓋。

       簡單一句：成員函數，編譯看引用型變量所屬的類，運行看對象所屬的類。

       更簡單：成員函數 --- 編譯看 = 左邊，運行看 = 右邊。

   3，靜態函數。

       編譯時期：參考的是引用型變量所屬的類中是否有調用的成員。

       運行時期：也是參考引用型變量所屬的類中是否有調用的成員。

       為什么是這樣的呢？因為靜態方法，其實不所屬于對象，而是所屬于該方法所在的類。

       調用靜態的方法引用是哪個類的引用調用的就是哪個類中的靜態方法。

       簡單說：靜態函數 --- 編譯運行都看 = 左邊。

Objiec類

   equals方法，toString方法

   示例：

/*object:是所有對象的直接或者間接父類，傳說中的上帝。
該類中定義的肯定是所有對象都具備的功能。
如果自定義類中也有比較相同的功能，沒有必要重新定義。
只要沿襲父類中的功能呢，建立自己特有的比較內容即可。這就是覆蓋。
*/
class Demo
{
    private int num;
    Demo(int num)
    {
        this.num = num;
    }
    public boolean equals(Object obj)//復寫object中方法
    {
        if (obj instanceof Demo)
        {
            return false;
        }
        Demo d = (Demo)obj;
        return this.num ==d.num;
    }
    public String toString()//復寫object中方法
    {
        return "Demo:"+num
    }
}
class ObjectDemo
{
    public static void main(String[] args)
    {
        Demo d1 = new Demo(4);
        //Demo d2 = new Demo(5);
        //System.out.println(d1.equals(d2));
        //d1.getClass().getName();獲取d1的class對象，并調用getName方法。
        System.out.println(d1.getClass().getName()+"@"+Integer.toHexString(d1.hashCode()));
        System.out.println(d1.toString());
                                                                                                                                       
    }
}

內部類

   內部類訪問規則：

       1，內部類可以直接訪問外部類中的成員，包括私有。

       之所以可以直接訪問外部類中的成員，是因為外部類中持有了一個外部類的引用。格式是：外部類名.this

       2，外部類要訪問內部類，必須建立內部類對象。

   訪問格式：

       1，當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中直接建立內部類對象。

           格式：外部類名.內部類名變量名 = 外部類對象.內部類對象；

                 Outer.Inner in = new Outer().Inner();

       2，當內部類在成員位置上，就可以被成員修飾符所修飾。

           比如：private：將內部類在外部類中進行封裝。

           static：內部類就具備static的特性。

           當內部類被static修飾后，只能直接訪問外部類中的static成員，出現訪問局限。

           在外部其他類中，如何直接訪問static內部類的非靜態成員呢？new Outer.Inner().function();

           在外部其他類中，如何直接訪問static內部類的靜態成員呢？Outer.Inner.function();

       注意:當內部類中定義了靜態成員，該內部類必須是static的。

           當外部類中的靜態方法訪問內部類時，內部類必須是靜態的。

3，內部類定義在局部時：

   1，不可以被成員修飾符修飾。

   2，可以直接訪問外部類中的成員，因為還持有外部類中的引用。但是不可以訪問他所在的局部中的變量，只能訪問被final修飾的局部變量。

   內部類的使用：

       當描述事物，事物中的內部還有事物，該事物用內部類來描述。

       因為內部事物在使用外部事物的內容。

       內部類編譯后的文件名為：“外部類名$內部類名.java”；

匿名內部類：

   1，匿名內部類其實就是內部類的簡寫格式。

   2，定義匿名內部類的前提：內部類必須是繼承一個類或者實現接口。

   3，匿名內部類的格式：new 父類或者接口(可傳參數){定義子類的內容}

   4，其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。可以理解為帶內容的對象。

   5，匿名內部類中定義的方法最好不要超過2個，即1或2個。

示例代碼：

/*object:是所有對象的直接或者間接父類，傳說中的上帝。
該類中定義的肯定是所有對象都具備的功能。
如果自定義類中也有比較相同的功能，沒有必要重新定義。
只要沿襲父類中的功能呢，建立自己特有的比較內容即可。這就是覆蓋。
*/
class Demo
{
    private int num;
    Demo(int num)
    {
        this.num = num;
    }
    public boolean equals(Object obj)//復寫object中方法
    {
        if (obj instanceof Demo)
        {
            return false;
        }
        Demo d = (Demo)obj;
        return this.num ==d.num;
    }
    public String toString()//復寫object中方法
    {
        return "Demo:"+num
    }
}
class ObjectDemo
{
    public static void main(String[] args)
    {
        Demo d1 = new Demo(4);
        //Demo d2 = new Demo(5);
        //System.out.println(d1.equals(d2));
        //d1.getClass().getName();獲取d1的class對象，并調用getName方法。
        System.out.println(d1.getClass().getName()+"@"+Integer.toHexString(d1.hashCode()));
        System.out.println(d1.toString());
          
    }
}