2. 程式人生 > >java 面向物件三大特性之一：繼承

java 面向物件三大特性之一：繼承

阿新 • • 發佈：2019-01-27

      前言：

   繼承，既是對現有類的複用。如果子類繼承了父類，那麼子類就擁有了父類的能力了。除此之外，子類還能加入自己新加入的方法，功能，或是重新定義從父類繼承的某項功能。這樣，就可以在現有的功能上開發新的功能，這樣能大大減少開發的週期.

|繼承的優點|

 現在我們來構建一個Cat的類

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 13:202018/3/12
 */

/**
 * 貓類
 */
public class Cat {
    private int age;//年齡
    private int weigth;//體重
    private String name;//名字

    public int getAge() {
        return age;
    }
    public Cat(int age,int weigth,String name){
        this.age=age;
        this.weigth=weigth;
        this.name=name;

    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getWeigth() {
        return weigth;
    }

    public void setWeigth(int weigth) {
        this.weigth = weigth;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void printMessage(){
        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge());
    }
    public  Cat(){}

}

這個Cat類包含體重 名字 身高等資訊，但現在我想要在這個Cat的基礎上建立一個EgyptianCat的類，我要重新把之前的程式碼重新再寫一次然後再新增新的東西下去嗎？很顯然這會十分的麻煩且無用，所以這時候extend 這個關鍵字發揮了他的用處了

public class EgyptianCat extends Cat {
    private  String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public EgyptianCat(int height,int weigth,String name,String color){
        super(height,weigth,name);
        this.color=color;
    }

    @Override
    public void printMessage() {

        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge()+"color:"+getColor());
    }
}

和Cat相比，EgyptianCat就多了個一個私用屬性color，通過extend繼承，我們的類構建可以簡潔很多，並且可以在繼承的基礎上重新構建一個屬於我們新類的方法，這種方法叫做重寫方法（PS：重寫方法會呼叫上一層繼承的被重寫方法）

這裡我們重寫了父類的printMessage()方法，在列印資訊中新加入了color屬性

現在我們來new下父類和子類並且呼叫他們的printMessage方法檢視下結果

 public static void main(String[] args) {
        Cat cat = new Cat(2,10,"jay");
        cat.printMessage();
        EgyptianCat egyptianCat = new EgyptianCat(3,5,"lois","black");
        egyptianCat.printMessage();

    }

輸出結果為：

name:jay weigth:10kg  age:2
name:lois weigth:5kg  age:3 color:black

|成員的繼承|

如果子類繼承了父類，則：

1.子類繼承父類的所有public與protect成員，無論子類是否與父類在同一個包中；

2.如果子類與父類在同一個包中，那麼子類也會繼承父類包訪問許可權

3.子類不能繼承父類的私有成員，但是子類可以通過父類的public或protect方法間接訪問父類的私有成員

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 22:212018/3/13
 */
public class SuperClass {
    public int public_value;
    protected  int protect_value;
    private int private_value;
    public SuperClass(){
        public_value=1;
        protect_value=2;
    }

    public int getPrivate_value() {
        return private_value;
    }

    public void setPrivate_value(int private_value) {
        this.private_value = private_value;
    }
}

在SuperClass這個類中我們宣告三種訪問許可權的變數，讓我們看下他的子類是怎麼繼承成員變數的

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 22:242018/3/13
 */
public class ExtendClass extends SuperClass {


    public void printMessage() {
        System.out.println("public value:"+public_value);
        System.out.println("protect value"+protect_value);
        // System.out.println("private value"+private_value); 並不能直接訪問私有屬性
        System.out.println("private value:"+getPrivate_value());
    }

    public static void main(String[] args) {
        ExtendClass extendClass = new ExtendClass();
        extendClass.setPrivate_value(3);
        extendClass.printMessage();

    }
}

我們新建立了一個ExtendClass類，其中聲明瞭一個printMessage打印出成員變數的資訊，讓我們看下結果吧

public value:1
protect value2
private value:3

結果說明，子類能直接繼承父類的public和protect成員變數，但並不能直接繼承私有變數，但能通過setter和getter方法來訪問private變數

|繼承的向上轉型和向下轉型|

如果子類繼承了父類，那麼我們可以認為子類是父類的其中一種，是父類的特殊拓展版，例如Cat類繼承於Animal類，那麼我們可以把Cat看做為Animal,Cat具有Animal的所有特徵，但並不能把Animal看做為Cat，因為並不是所有的Animal都是Cat.

 在Java中，我們可以把父類的引用賦值給子類的物件，然後通過父類的引用來進行操作，這種操作被稱為向上轉型，但是，子類的新增方法並不能進行使用和操作。我們不能把子類的引用賦值給父類的物件，就像前面所說的，可以把Cat看做為Animal,Cat具有Animal的所有特徵，但並不能把Animal看做為Cat，因為並不是所有的Animal都是Cat.

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 22:432018/3/13
 */
public class Animal {
    public void walk(){
        System.out.println("Animal walk!!");
    }
    public void sleep(){
        System.out.println("Animal sleep!!");
    }
    public void eat(){
        System.out.println("Animal eat!!");
    }
}

我們現在建立一個Animal類，然後我們再建立一個Cat類繼承於Animal類

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 13:202018/3/12
 */

/**
 * 貓類
 */
public class Cat extends Animal {
    private int age;//年齡
    private int weigth;//體重
    private String name;//名字

    public int getAge() {
        return age;
    }
    public Cat(int age,int weigth,String name){
        this.age=age;
        this.weigth=weigth;
        this.name=name;

    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getWeigth() {
        return weigth;
    }

    public void setWeigth(int weigth) {
        this.weigth = weigth;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void printMessage(){
        System.out.println("name:"+getName()+" weigth:"+getWeigth()+"kg  age:"+getAge());
    }
    public  Cat(){}
     public void  Meow(){
         System.out.println("meow!!!!");
     }
}

其中Cat類中新增了一個Meow的貓叫方法

現在我們來測試一下：

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 22:492018/3/13
 */
public class Test {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();
        cat.sleep();
        cat.walk();
        //但是不能呼叫Meow這個方法，現在我們把cat引用轉為Cat
        cat=(Cat) cat;
        ((Cat) cat).Meow();
        //Cat animal = new Animal(); 編譯器報錯，並不能向下轉型！

    }
}

結果：

Animal eat!!
Animal sleep!!
Animal walk!!
meow!!!!

正如之前所說的一樣，父類引用指向子類物件不能使用子類自己新增的方法，而且如果向下轉型的話編譯器會報錯，那麼向下轉型有什麼作用呢？之後我們會提到.

|多型的實現|

 現在我們要編寫一個動物園類，檢查傳入的動物是什麼動物

package Test.practice.thinking_in_java.extend_test;

/**
 * @Author 7aY
 * @Description: TODO()
 * @Date :Create in 0:212018/3/15
 */
public class Zoo {
    //動物園檢查動物
    public void check(Animal animal){
        System.out.println("this is animal!");

    }
    public void check(Cat cat){
        System.out.println("this is cat!");

    }
    public void check(EgyptianCat egyptianCat){
        System.out.println("this is egyptianCat!");

    }

    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        Animal animal = new Animal();
        Cat cat = new Cat();
        EgyptianCat egyptianCat = new EgyptianCat();
        zoo.check(animal);
        zoo.check(cat);
        zoo.check(egyptianCat);
    }
}

結果：

this is animal!
this is cat!
this is egyptianCat!

以上的程式碼是check方法的過載,看上去沒有任何問題.但只要我們稍加修改，用到上面的向上轉型，結果則會出人意料

  public static void main(String[] args) {
        Zoo zoo = new Zoo();
        Animal animal = new Animal();
        Cat cat = new Cat();
        Animal egyptianCat = new EgyptianCat();
        zoo.check(animal);
        zoo.check(cat);
        zoo.check(egyptianCat);
    }
}

輸出結果：

this is animal!
this is cat!
this is animal!

這是因為方法過載是靜態的，傳入引數型別是看型別的引用，前面cat的引用型別是Animal，所有編譯器自動把cat傳到Animal的過載方法中。

現在我們稍加修改

public class Zoo {
    //動物園檢查動物

    public void check(Animal animal){
        animal.printInfo();
    }

    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        Animal animal = new Animal();
        Cat cat = new Cat();
        Animal egyptianCat = new EgyptianCat();
        zoo.check(animal);
        zoo.check(cat);
        zoo.check(egyptianCat);
    }
}

結果為：

this is Animal
this is cat
this is EgyptianCat

這裡說明一下，Animal 、Cat、EgyptianCat類中都有一個printInfo方法打印出自身的資訊

從結果可以看出，雖然是向上轉型，但是仍能準確輸出類的資訊，並且在Zoo類中並不需要過載方法，試想一下每當有一個新的類出現就過載一次，那麼這個Zoo類的過載方法是不是太多了，以後管理起來也不方便，但使用多型的話，這需要在子類中重寫方法即可，十分的方便。

【總結】

 使用繼承這個關鍵字extend 能減少我們程式碼編寫的工作量，但在重寫的時候要注意，例如重寫，類的變數繼承等

因為有了繼承，使得程式碼的複用有了千變萬化的機會










相關推薦

java 面向物件三大特性之一：繼承

      前言：   繼承，既是對現有類的複用。如果子類繼承了父類，那麼子類就擁有了父類的能力了。除此之外，子類還能加入自己新加入的方法，功能，或是重新定義從父類繼承的某項功能。這樣，就可以在現有的功能上開發新的功能，這樣能大大減少開發的週期.|繼承的優點| 現在我們來構建

Java面向物件三大特性-封裝、繼承、多型

在講Java面向三大特性之前，我們先了解一下訪問修飾符的訪問範圍： （1）：private：同類中具有訪問許可權。 （2）：protected：本類 和同包以及不同包的子類才具有訪問許可權。 （3）：public：統一工程中都具有訪問許可權。 （4）：預設 本類和同包範圍內具有訪問許可權。 一、Ja

Java面向物件三大特性一：多型詳解

多型 多型(polymorphism):指的是同一個方法呼叫，由於物件不同可能會有不同的行為。現實生活中，同一個方法，具體實現會完全不同。 所謂多型就是指程式中定義的引用變數所指向的具體型別和通過該引用變數發出的方法呼叫在程式設計時並不確定，而是在程式執行期

補習：C# 面向物件三大特性:封裝、繼承、多型

C# 面向物件三大基本特性 封裝、繼承、多型 1、封裝 隱藏物件的屬性和實現細節，僅對外公開介面，控制在程式中屬性的讀取和修改的訪問級別。 C# 封裝根據具體的需要，設定使用者的訪問許可權，並通過 訪問修飾符 來實現。 一個 訪問修飾符 定義了一個類成員的範圍和可

python面向物件三大特性之一繼承

繼承 即在定義一個類時，以另一個類為引數，則稱這個新定義的類繼承了引數類，父類又稱為基類。 單繼承表示只繼承一個類，多繼承表示繼承多個類。 class parent1: pass class parent2: pass class sub1(parent1):#單繼承 pa

java面向物件三大特性之繼承

1、繼承 1 .1、繼承的總說明 1、子類繼承父類，可以繼承父類的全部屬性和方法（ 除了父類的構造方法） 2、java只有單繼承一個子類只有一個父類不能有多個父類（c+±-） 3、如果定義一個類沒有

第二十四、Java面向物件三大特性之繼承與super關鍵字

面向物件的三大特徵：1. 封裝2. 繼承3. 多型. 1、類和類之間的常見關係     1：既然繼承是描述類和類之間的關係，就需要先來了解類和類之間的常見關係 1.1  現實生活的整體與部分 舉例說明 1：現實生活     1：學生   是人      2：狗    

python面向物件三大特性之一封裝

一、什麼是封裝 　　在程式設計中，封裝（Encapsulation）是對具體物件的一種抽象，即將某些部分隱藏起來，在程式外部看不到，其 含義是其他程式無法呼叫。 　　要了解封裝，離不開“私有化”，就是將類或者是函式中的某些屬性限制在某個區域之內，外部無法呼叫。 　　二、為什麼要封裝 　　封裝資料的主

JAVA面向物件三大特性以及抽象類、介面

初識JAVA面向物件 提起面向物件，我們也就想到了面向過程。那麼何為面向物件呢？簡言之萬物皆物件…眾生芸芸，雲裡霧裡不能自已。 好了，步入正題，面向物件是JAVA這門語言的核心所在。要想使用這門語言在猿界立足，一定得要有面向物件的這種程式設計思想。 一、面向物件

php面向物件三大特性之一封裝

1.就是物件的成員（屬性，方法）結合成一個獨立的相同單位，並儘可能隱藏物件的內部細節private 私有的，用這個關鍵字修飾的成員，只能在物件內部訪問（只能用$this訪問），不能在物件外部使用2.這個類中有100個方法，封裝了95個（為另外5個服務的方法），只有5個方法可以

Java基礎1——深入理解Java面向物件三大特性

深入理解Java面向物件三大特性 Java的三大特性：封裝、繼承和多型 封裝：   通常認為封裝是把資料和操作資料的方法繫結起來，對資料的訪問只 能通過已定義的介面。面向物件的本質就是將現實世界描繪成一系列完全自 治、封閉的物件。我們在類中編寫的方法就是對實現細節的一種封裝；我們

面向物件三大特性-----封裝、繼承、多型

前言 　　前面有文章寫到了面向物件程式設計和麵向物件設計的頭五大原則(SOLID五大原則)。今天我們再來談談面向物件的三大特性--封裝、繼承、多型 封裝  　　被定義為"把一個或多個專案封閉在一個物理的或者邏輯的包中"。在面向物件程式設計方法論中，封裝是為了防止對實現細節的訪問。封裝只公開某些

java基礎-------面向物件三大特性：封裝、繼承、多型

面向物件三大特性： 封裝、繼承、多型； 一、封裝 1、定義： 封裝就是將類的資訊隱藏在類內部，不允許外部程式直接訪問，而是通過該類的方法實現對隱藏資訊的操作和訪問。 2、實現方法： 使用private關鍵字修飾 類內部的屬性； 3、如何訪問： 在類內部定義get、set方法，實行使用物件呼叫

面向物件三大特性：封裝、繼承、多型

封裝： 將屬性和方法放到一起做為一個整體，然後通過例項化物件來處理； 隱藏內部實現細節，只需要和物件及其屬性和方法互動就可以了； 對類的屬性和方法增加 訪問許可權控制。 私有許可權：在屬性名和方法名 前面 加上兩個下劃線 __ 類的私有屬性 和 私有

【C++】：面向物件三大特性之繼承

面向物件三大特性之繼承 1.繼承的概念及定義 2.基類和派生類物件賦值相互轉化 3.繼承時的作用域 4.派生類中的預設成員函式 5.繼承的友元和靜態成員 6.菱形繼承和菱形虛擬繼承 7.組合和繼承 1.繼承的概念

面向對象3大特性之一：繼承

prot 出現 初始化過程 子類 接口 我們 logs 類的構造函數 com 繼承 繼承表示一個類型（子類）派生自（繼承於）一個基類型（父類），該類型將擁有基類型的所有成員字段和函數（不包括構造函數和析構函數）。 註意： 派生類繼承基類的所有成員，不管是public、pr

封裝繼承多型-java面向物件三大特徵

第七章  封裝和繼承一、面向物件的三大特徵    封裝、繼承、多型二、封裝    將類的屬性（欄位）設定為私有的(private)，並新增getter/setter方法操作屬性。    注意：get|set方法

面向物件三大特性—繼承

什麼是繼承 在現實生活中，經常發生子承父業的事情，同樣的，在java中也有類似的“子承父業”的情況。也就是我們今天要說的繼承。如果說我們在Java專案中有兩個類的功能極其相似或者一個類的功能是在另一個類的基礎上實現的。那麼我們寫兩份比較相似程式碼就極大的浪費了我們的時間和經

***Java基礎面向物件三大特性淺談***

1、繼承：繼承是從已有類得到繼承資訊建立新類的過程。提供繼承資訊的類被稱為父類（超類、基類）；得到繼 承資訊的類被稱為子類（派生類）。繼承讓變化中的軟體系統有了一定的延續性，同時繼承也是封裝程式中可變因素的重要手段。 2、 封裝：通常認為封裝是把資料和操作資料的方法繫結起來，對資料的訪問

【C++】：面向物件三大特性之多型

面向物件三大特性之多型 1. 什麼是多型？ 2.多型的兩個構成條件 2.1 虛擬函式 2.2 虛擬函式的重寫和協變 2.3 一些不規範的重寫行為 2.4 解構函式的重寫問題 2.5 為什麼