2. 程式人生 > >繼承與多型之動手動腦

繼承與多型之動手動腦

阿新 • • 發佈：2019-10-23

繼承與多型

一、繼承條件下的構造方法的呼叫

class Grandparent 
{


    public Grandparent()
     {

            System.out.println("GrandParent Created.");
    
}


    public Grandparent(String string) 
    {

            System.out.println("GrandParent Created.String:" + string);
    
 }

}



class Parentt extends Grandparent
{


    public Parentt()
     {

            super("Hello.Grandparent.");

            System.out.println("Parent Created");
    
       // super("Hello.Grandparent.");

      }
    public Parentt(String s)
    {
        System.out.println("Parent Created.String:"+s);
    }

}



class Childd extends Parentt 
{


    public Childd()
     {
        super("Hello.Parent.");
        System.out.println("Child Created");

      }

}



public class TestInherits 
{


    public static void main(String args[])
     {

            Childd c = new Childd();
    
  }

}

輸出：

GrandParent Created.
Parent Created.String:Hello.Parent.
Child Created

在構造子類的方法之前會先構造父類的方法，如果是多級繼承，會先執行最頂級父類的構造方法，然後依次執行各級個子類的構造方法。若想在子類中呼叫父類的有參構造方法，需要在子類的構造方法的第一行加上super方法，注意：只能是第一行

為什麼子類的構造方法在執行之前，必須呼叫父類的構造方法？能不能反過來？為什麼不能反過來？

因為子類繼承自父類，會沿用父類的東西(沒被覆蓋的函式以及可見的成員變數等)，而這些東西子類是沒有的，需要先初始化父類才能被使用。
 
構造一個物件，先呼叫其構造方法，來初始化其成員函式和成員變數。
子類擁有父的成員變數和成員方法，如果不呼叫，則從父類繼承而來的成員變數和成員方法得不到正確的初始化。
不能反過來呼叫也是這個原因，因為父類根本不知道子類有神魔變數而且這樣一來子類也得不到初始化的父類變數，導致程式執行出錯！

 

二、不允許繼承的類

 

 

不可變的“類”有何作用：

①可方便和安全的用於多執行緒的環境中

②訪問他們不用加鎖，可高效能的執行

 

public final class Address
{
    private final String detail;
    private final String postCode;

    //在構造方法裡初始化兩個例項屬性
    public Address()
    {
        this.detail = "";
        this.postCode = "";

    }
    public Address(String detail , String postCode)
    {
        this.detail = detail;
        this.postCode = postCode;
    }
    //僅為兩個例項屬性提供getter方法
    public String getDetail()
    {
         return this.detail;
    }

    public String getPostCode()
    {
         return this.postCode;
    }
    //重寫equals方法，判斷兩個物件是否相等。
    public boolean equals(Object obj)
    {
        if (obj instanceof Address)
        {
            Address ad = (Address)obj;
            if (this.getDetail().equals(ad.getDetail()) && this.getPostCode().equals(ad.getPostCode()))
            {
                return true;
            }
        }
        return false;
    }
    public int hashCode()
    {
        return detail.hashCode() + postCode.hashCode();
    }
    public static void main(String args[])
     {

           Address add=new Address("123","456");
           System.out.println(add.getDetail());
           System.out.println(add.getPostCode());
           Address arr=new Address("123","456");
           System.out.println(add.equals(arr));
    
 }
}

輸出：

123
456
true

三、反彙編

public class ExplorationJDKSource {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(new A());
    }

}

class A{}

輸出：

A@15db9742

 

 我們用javap -c 來反編譯該檔案的.class檔案,得到：

 

 

點進object裡，發現tostring方法

 

 

 

 public void main（object x）呼叫了String類的valueOf方法，

 

 

 故而出現了這樣的輸出

三、神奇的“+”號和方法覆蓋

 

public class Fruit
{
        
    public String toString()
    {
        return "Fruit toString.";
    }

    public static void main(String args[])
    {
        Fruit f=new Fruit();
        System.out.println("f="+f);
        System.out.println("f="+f.toString());
    }
}

在輸出字串+物件時，會隱式的呼叫tostring（）的方法

方法的覆蓋：要求子類和父類的方法一樣，並且實現在子類中呼叫父類的被覆蓋的方法

class ABC
{
    public void print()
    {
        System.out.println("Parent print");
    }
}
public class test extends ABC{

    public void print()
    {
        super.print();
        System.out.println("Children print");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test t1=new test();
        t1.print();
    }

}

輸出：

Parent print
Children print

利用super（）的方法呼叫父類的物件，然後再呼叫父類的覆蓋方法

覆蓋的語法規則：

 

 

 四、如何判斷物件是否可以轉換

public class TestInstanceof
{
    public static void main(String[] args) 
    {
        //宣告hello時使用Object類，則hello的編譯型別是Object，Object是所有類的父類
        //但hello變數的實際型別是String
        Object hello = "Hello";
        //String是Object類的子類，所以返回true。
        System.out.println("字串是否是Object類的例項：" + (hello instanceof Object));
        //返回true。
        System.out.println("字串是否是String類的例項：" + (hello instanceof String));
        //返回false。
        System.out.println("字串是否是Math類的例項：" + (hello instanceof Math));
        //String實現了Comparable介面，所以返回true。
        System.out.println("字串是否是Comparable介面的例項：" + (hello instanceof Comparable));
        String a = "Hello";
        //String類既不是Math類，也不是Math類的父類，所以下面程式碼編譯無法通過
        //System.out.println("字串是否是Math類的例項：" + (a instanceof Math));
    }
}

輸出：

字串是否是Object類的例項：true
字串是否是String類的例項：true
字串是否是Math類的例項：false
字串是否是Comparable介面的例項：true

 

 

 型別轉換事例：

import java.net.InterfaceAddress;

class Mammal{}
class Dog extends Mammal {}
class Cat extends Mammal{}

public class TestCast
{
    public static void main(String args[])
    {
        Mammal m;
        Dog d=new Dog();
        Cat c=new Cat();
        m=d;
        //d=m;
        d=(Dog)m;
        //d=c;
        //c=(Cat)m;
        System.out.println("good");
    }
}

將子類dag賦值給基類m，可以實現，而將基類賦值給d需要進行強制型別轉換，兩個子類之間不能進行轉換，m已經是Dog類，不能再被強制轉換為Cat類

五、變態的類

public class ParentChildTest {
    public static void main(String[] args) {
        Parent parent=new Parent();
        parent.printValue();//100
        Child child=new Child();
        child.printValue();//200
        
        //父類變數去引用子類物件
        parent=child;
    
        parent.printValue();//呼叫子類的方法200
        
        //如果子類被當作父類使用,則通過子類訪問的欄位是父類的!
        parent.myValue++;
        System.out.println(parent.myValue);//101
        parent.printValue();//200
        
        ((Child)parent).myValue++;
        parent.printValue();
        
    }
}

class Parent{
    public int myValue=100;
    public void printValue() {
        System.out.println("Parent.printValue(),myValue="+myValue);
    }
}
class Child extends Parent{
    public int myValue=200;
    public void printValue() {
        System.out.println("Child.printValue(),myValue="+myValue);
    }
}

輸出：

Parent.printValue(),myValue=100
Child.printValue(),myValue=200
Child.printValue(),myValue=200
101
Child.printValue(),myValue=200
Child.printValue(),myValue=201

前兩個輸出沒問題，將子類賦值給基類物件，基類物件指向子類物件，呼叫的是子類的方法，故而輸出第三條，

parent.myValue++;就是將子類當成父類來使用，通過子類訪問的欄位是父類的所以，當輸出myvalue時是101，是父類的值+1；
最後將基類強制轉換成子類後，將value++，此時訪問的才是子類的欄位，故而輸出結果為201.

六、多型

package zoo4;
import java.util.Vector;

public class Zoo {

    public static void main(String args[]) {
        Feeder f = new Feeder("小李");
        Vector<Animal> ans = new Vector<Animal>();

        //飼養員小李餵養一隻獅子
        ans.add(new Lion());
        //飼養員小李餵養十隻猴子
        for (int i = 0; i < 10; i++) {
            ans.add(new Monkey());
        }
        //飼養員小李餵養5只鴿子
        for (int i = 0; i < 5; i++) {
            ans.add(new Pigeon());
        }
        f.feedAnimals(ans);
    }
}

class Feeder {

    public String name;

    Feeder(String name) {
        this.name = name;
    }

    public void feedAnimals(Vector<Animal> ans) {
        for (Animal an : ans) {
            an.eat();
        }
    }
}

abstract class Animal {

    public abstract void eat();
}

class Lion extends Animal {

    public void eat() {
        System.out.println("我不吃肉誰敢吃肉！");
    }
}

class Monkey extends Animal {

    public void eat() {
        System.out.println("我什麼都吃，尤其喜歡香蕉。");
    }
}

class Pigeon extends Animal {

    public void eat() {
        System.out.println("我要減肥，所以每天只吃一點大米。");
    }
}

輸出：

我不吃肉誰敢吃肉！
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我什麼都吃，尤其喜歡香蕉。
我要減肥，所以每天只吃一點大米。
我要減肥，所以每天只吃一點大米。
我要減肥，所以每天只吃一點大米。
我要減肥，所以每天只吃一點大米。
我要減肥，所以每天只吃一點大米。

通過定義一個抽象類anmial，來控制所以動物吃的功能，通過vector這個可變長陣列，來控制動物的增減，最終實現當再加入其他不同的動物時，用較少的修改來完成動物的新增。

除了可以用抽象類來實現，還可以使用介面的形式來實現

package zoo5;
import java.util.Vector;

public class Zoo {

    public static void main(String args[]) {
        Feeder f = new Feeder("小李");
        Vector<Animal> ans = new Vector<Animal>();

        //飼養員小李餵養一隻獅子
        ans.add(new Lion());
        //飼養員小李餵養十隻猴子
        for (int i = 0; i < 10; i++) {
            ans.add(new Monkey());
        }
        //飼養員小李餵養5只鴿子
        for (int i = 0; i < 5; i++) {
            ans.add(new Pigeon());
        }
        f.feedAnimals(ans);
    }
}

class Feeder {

    public String name;

    Feeder(String name) {
        this.name = name;
    }

    public void feedAnimals(Vector<Animal> ans) {
        for (Animal an : ans) {
            an.eat();
        }
    }
}

interface Animal {

    public void eat();
}

class Lion implements Animal {

    public void eat() {
        System.out.println("我不吃肉誰敢吃肉！");
    }
}

class Monkey implements Animal {

    public void eat() {
        System.out.println("我什麼都吃，尤其喜歡香蕉。");
    }
}

class Pigeon implements Animal {

    public void eat() {
        System.out.println("我要減肥，所以每天只吃一點大米。");
    }
}

抽象類與抽象方法

 

 

 抽象類的三種方法：

 

 抽象類不能用來建立物件，一般用他來引用子類的物件

 

 

 介面：

 

 介面的使用：

 

 介面的擴充：

 

 介面與抽象類的區別：

&n

相關推薦

繼承與多型之動手動腦

繼承與多型 一、繼承條件下的構造方法的呼叫 class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); }

繼承和多型之動手動腦

1. package cs4; class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); } public Gra

課堂（繼承與多態）動手動腦

類構造 註意 調用父類 變量賦值 出錯 指定 and 技術 eof 01.怎樣判斷對象是否可以轉換？ 答：可以使用instanceof運算符判斷一個對象是否可以轉換為指定的類型 02. 現在有三個類: class Mammal{} class Dog extends Mam

繼承與多型動手動腦總結

一：繼承條件下的構造方法呼叫 程式程式碼： class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); } pub

03繼承與多型 動手動腦

動手實驗：繼承條件下的構造方法呼叫 執行 TestInherits.java 示例，觀察輸出，注意總結父類與子類之間構造方法的呼叫關係修改Parent構造方法的程式碼，顯式呼叫GrandParent的另一個建構函式，注意這句呼叫程式碼是否是第一句，影響重大！ class Grandp

小白學python之繼承與多型_學習筆記

本文以廖雪峰的官方網站為參考來學習python的。其學習連結為廖雪峰小白學python教程。 本文是學習到python的繼承與多型。參考連結廖雪峰python繼承與多型。 class Animal(object): def run(self): print('Anim

Java之路：類的封裝、繼承與多型

面向物件有三大特點：封裝性、繼承性和多型性。 一、封裝 1、封裝的含義 封裝 (Encapsulation)是將描述某類事物的資料與處理這些資料的函式封裝在一起，形成一個有機整體，稱為類。 類所具有的封裝性可使程式模組具有良好的獨立性與可維護性，這對大型程式的開發是特別重要的

【C#】之 封裝、繼承與多型

我們知道封裝、繼承和多型是面向物件方法設計中的三大基本特性，下面將具體講解這三個特性的具體表現及意義。 #一、封裝 ##1、說明 　　從字面意思上看，封裝就是打包的意思，將什麼包裝起來，專業一點就是資訊的隱藏，將物件的屬性和方法打包成一個相對獨立的單位，儘可能隱蔽物件的內部細

Java面向物件與多執行緒綜合實驗（一）之封裝、繼承與多型

編寫一個程式，實現檔案管理系統中的使用者管理模組。要求模組中實現使用者的模擬登入過程。通過使用者輸入，獲取使用者名稱和口令；與事先記錄在程式中的使用者資訊進行對比，通過口令驗證後才能使用系統。使用者分為系統管理人員、檔案錄入人員，檔案瀏覽人員三類，相關類圖如下所示。 （1）要求在使用者類中

JAVA基礎之封裝、繼承與多型

封裝、繼承、多型 1、封裝：隱藏實現細節，明確標識出允許外部使用的所有成員函式和資料項，從而防止程式碼或資料被破壞。 2、繼承：子類繼承父類，擁有父類的所有功能，並且可以在父類的基礎上進行擴充套件。實現了程式碼的重用性。子類和父類是相容的。 3、多型：一個介面有多個子類或實現類，

Python3 與 C# 面向物件之～繼承與多型

Python的多繼承最好是當C#或者Java裡面的介面使用，這樣結構不會混亂( 特殊情況除外) 來個例子： class Animal(object): pass class Flyable(object): """飛的方法""" pass class Ru

C++之繼承與多型

在程式設計領域，一個廣泛認可的定義是“一種將不同的特殊行為和單個泛化記號相關聯的能力”。和純粹的面向物件程式設計語言不同，C++中的多型有著更廣泛的含義。除了常見的通過類繼承和虛擬函式機制生效於執行期的動態多型（dynamic polymorphism）外，帶變數的巨集，模板，函式過載，運算子過載，拷貝構造等

關於繼承與多型的簡單認識

（1）繼承條件下的構造方法呼叫 package Demo1; class Grandparent { public Grandparent() { System.out.println("GrandParent Created.");

第10章 介面、繼承與多型

10.1 package tex; public abstract class one { abstract void test(); public static void main(String args[]) { new one(); } } //無法例項化 10.2 p

繼承和多態中動手動腦

class 分享 9.png int pos log val info 同名 當子類對象和父類對象調用同名的方法的時候，只看這個對象是子類還是父類，調用他最真實的類中的方法。 這個是println調用的方法的不同，實際上他調用了內部的String類的valueOf方法

繼承與多型的一個簡單例項

程式結構： 父為Person類,Person類個子類Student和Employee，Employee類又有兩個子類，Staff和Faculty。 繼承即子類可以繼承父類的資料域和方法： Student類和Employee類繼承了Person類的資料域name，address pho

Python：父類的多繼承與多型

#父類的多繼承 例：孩子繼承父親以及母親的屬性 #父親屬性 class Father(object) : def __init__(self,money): self.money = money def Running(self): pri

C++設計模式-繼承與多型影響耦合性（最基礎的簡單工廠模式小例項）

繼承與多型影響耦合性（最基礎的簡單工廠模式小例項） 原理： 通過繼承和虛擬函式的方式修改某個子類對應函式的功能； 通過簡單工廠模式到底例項化誰; 如果要增加複雜的運算只有增加響應的子類，以及工廠的分支即可；   程式執行截圖如下：   目錄結構如

Java三大特性：封裝，繼承與多型

（尊重勞動成果，轉載請註明出處：https://blog.csdn.net/qq_25827845/article/details/84592274冷血之心的部落格）           面向物件的語言有三大特性，即封裝繼承與多型。三大特

C++【繼承與多型】

兩個類間的關係：組合與繼承 繼承：可以使用現有類的所有功能，並在無需編寫原來的類的情況下對這些功能進行擴充套件。 通過繼承建立的新類稱為“子類”或“派生類”。   被繼承的類稱為“基類”，“父類”或“超類”。 繼承的作用：程式碼的複用 訪問許可權