第十天 面向物件-繼承&抽象類【悟空教程】

第10天 面向物件

第1章 繼承

1.1 繼承概念

1.1.1 繼承概述

繼承是面向物件的核心特性，是面向物件的學習重點。同時繼承是程式碼複用的重要方式，可以表示類與類之間的關係，是所有面向物件語言不可缺少的組成部分。

1.1.2 繼承概念

當一個類的屬性與行為均與現有類相似，屬於現有類的一種時，這一個類可以定義為現有類的子類。

或者換成相反的角度來看，如果多個類具有相同的屬性和行為，我們可以抽取出共性的內容定義父類，這時再建立相似的類時只要繼承父類即可。

子類擁有父類的所有屬性與方法，無需重新定義。並且可以直接使用非私有的父類成員。

從類與類之間的設計關係來看,子類必須屬於父類的一種時，才會繼承。

我們在完成一個龐大專案體系的時候，都是將共性的內容抽取出，後續構建過程是從各種父類“向外”擴散的。

下例展示了一個繼承關係

圖1-1 動物繼承關係圖

動物類可以有姓名、年齡的成員變數，可以有吃飯、睡覺的方法。

所有貓科與犬科均有動物的成員變數與成員方法，且貓科與犬科均屬於動物，所以貓科與全科均可以繼承動物類。

貓科可以在動物的基礎上再新增抓老鼠的方法

犬科可以在動物的基礎上再新增看門的方法

犬科與貓科仍可以繼續出現子類，如波斯貓、巴釐貓、沙皮狗、斑點狗等，而其子類仍可以再出現該品種的特性。

1.2 繼承定義及使用格式

1.2.1 繼承定義

class 子類 extends 父類{

//父類的非私有方法與屬性均繼承過來

}

如：

父類的定義：

class Person{

private String name;

public void eat(){

System.out.println(“吃飯”);

}

get/set方法

}

子類繼承父類的定義：

class Chinese extends Person{}

1.2.2 繼承使用

繼承關係的產生通常是為了定義出功能更為具體、更為強大的子類。所以，定義子類後，一般建立子類物件使用。子類可以直接使用父類非私有的成員變數與成員方法

(注：如果成員變數沒有使用private修飾，則子類也可直接訪問。)

子類的使用：

class Test{

public static void main(String[] args) {

Chinese  c = new Chinese();

c.setName(“張大力”);

String name = c.getName();

System.out.println(name);//列印結果為張大力

c.eat();  //列印結果吃飯

}

1.3 繼承注意事項

• Java只支援單繼承，不支援多繼承。即只能有一個父類。

• 父類可以繼續有父類。

• 所有類均有父類，只有Object類沒有父類。

• 在所有使用父類型別的地方均可以傳入其子類物件。

/*

* Animal的類

* 屬性

*       name

*         age

* 行為

*         吃

*         睡

*/

public  abstract class Animal {

//成員變數

private String name;

private int age;

// //吃

// public abstract void eat();

//睡

public void sleep(){

System.out.println("睡");

}

//-----------get/set-------------------

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

/*

*定義一個貓類

* 屬性

*  name  

*  age

*  kind

* 行為

*  吃

*  睡

*  抓老鼠

*/

public class Cat extends Animal{

private String kind;

// @Override

// public void eat(){

//  System.out.println("貓吃魚");

// }

//貓特有的功能  抓老鼠

public void catchMouse(){

System.out.println("抓耗子");

}

public String getKind() {

return kind;

}

public void setKind(String kind) {

this.kind = kind;

}

}

/*

*定義一個狗類

* 屬性

*  name  

*  age

*  kind

* 行為

*  吃

*  睡

*  看門

*/

public class Dog extends Animal{

private String kind;

// @Override

// public void eat(){

//  System.out.println("狗吃肉");

// }

//狗特有功能  看門

public void lookDoor(){

System.out.println("看門");

}

public String getKind() {

return kind;

}

public void setKind(String kind) {

this.kind = kind;

}

}

/*

* 自定義型別 家

*

* 地址

*

* 行為

* 在家吃飯

*/

public class Home {

private String address;

//動物在家吃飯

//在所有使用父類型別的地方均可以傳入其子類物件。

public void eatAtHome(Animal a){

//呼叫Animal的eat方法

//a.eat();  

}

//狗在在家吃飯

// public void eatAtHome(Dog dog){

//  System.out.println("狗在家吃了");

//  //呼叫狗的eat方法

//  dog.eat();

// }

//貓在家吃飯

// public void eatAtHome(Cat cat){

//  System.out.println("貓在假吃了");

//  //呼叫貓的eat方法

//  cat.eat();

// }

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

}

/**

* 測試家類

*/

public class Test {

public static void main(String[] args) {

//  建立Home物件

Home home = new  Home();

//  Animal a = new Animal();  

//  home.eatAtHome(a);  

//在所有使用父類型別的地方均可以傳入其子類物件。

Dog d = new Dog();

home.eatAtHome(d);

Cat c = new Cat();

home.eatAtHome(c);  

}

}

1.4 方法重寫

1.4.1 方法重寫概念

當子類繼承父類後，擁有了父類的成員並可以直接呼叫父類非私有方法。如果子類認為父類提供的方法不夠強大，子類可以按照子類自身的邏輯重新定義繼承過來的父類方法，這個重新定義一個方法的過程叫做方法重寫。

(注：在學習完多型和抽象類後我們會對方法重寫有更深的理解)

1.4.2 方法重寫格式

子類中定義與父類一樣的方法便將父類的方法重寫了。此時，當建立子類物件，呼叫方法時，會呼叫子類重寫後的方法。如：

子類中定義與父類一樣的方法宣告即是方法重寫。

如：

• 父類定義：

public class Person{

private String name;

public void eat(){

System.out.println(“吃飯”);

}

get/set

}

• 子類定義：

public class Chinese extends Person{

@override //@override是用於強制規定當前定義的方法一定為重寫的方法

public void eat() {

System.out.println(“按照中國的習慣，使用筷子吃”);

}

}

• 子類的使用：

public class Test{

public static void main(String[] args) {

Chinese  c = new Chinese();

c.setName(“張大力”);  //父類繼承方法直接呼叫

String name = c.getName(); //父類繼承方法直接呼叫

System.out.println(name); //列印結果為張大力

c.eat();   //方法重寫後呼叫的為重寫後的方法

//列印結果：按照中國的習慣，使用筷子吃

}

}

/**

* 自定義型別  人類

*

*    姓名  年齡

*/

public class Person {

String address;

private String name;

private int age;

public void eat(){

System.out.println("吃");    

}

public void sleep(){

System.out.println("睡");

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

/*

* 定義型別  學生類

*

* 姓名  年齡

*

* 繼承

*   概念1  當定義一個類時，發現現有類與要定義的類類似，並且要定義的類屬於現有類的一種時，

*   就可以將這個類定義為現有類的子類

*  

*   子類擁有父類的所有屬性與方法，無需重新定義。並且可以直接使用非私有的父類成員。

*  

*   父類私用的成員變數  可以使用get/set方法 訪問

*   父類私有的方法  沒有辦法直接方法  雖然繼承了 但是相當於沒有

*    

*   子類可以有自己特有的屬性和方法

*  

*   方法重寫

*   子類繼承父類後，可以直接使用父類的非私有成員，但是如果覺得父類的成員方法不夠強大，子類可以按照自身的邏輯

*   將繼承過來的父類方法，進行重寫（方法重寫，方法複寫，方法覆蓋）

*  

*   可以使用@Override來驗證你的方法是不是重寫方法。

*/

public class Student extends Person{

private String number;

public void method(){

System.out.println(address);

System.out.println(getName());

}

//重寫父類eat方法

@Override

public void eat(){

System.out.println("學生吃學生套餐");

}

public String getNumber() {

return number;

}

public void setNumber(String number) {

this.number = number;

}

}

/*

* 測試繼承後的Studnet

*/

public class Test {

public static void main(String[] args) {

//建立Studnet物件

Student s = new Student();

s.setName("柳柳");

s.setNumber("0900112");

s.eat();

//  s.sleep();

String name = s.getName();

System.out.println(name);

System.out.println(s.getNumber());

System.out.println("-----------------");

//子類呼叫自己特有的方法

s.method();  

}

}

1.4.3 Java中方法重寫規則

• 子類重寫方法時，在宣告前加@Override可檢測該方法是否為重寫的方法

• 訪問許可權相同或子類方法訪問許可權更大(訪問許可權順序public>預設)

class Fu{

void show(){}

   public void method(){}

}

class Zi extends Fu{

public void show(){}  //編譯執行沒問題

   void method(){}      //編譯錯誤

}

• 方法名稱必須相同

• 引數列表必須相同

• 返回值為基本型別時必須相同

• 返回值為引用型別時相同或子類小(瞭解)

/*

* 方法重寫的注意事項

*  子類重寫方法時，在宣告前加@Override可檢測該方法是否為重寫的方法

*  訪問許可權相同或子類方法訪問許可權更大(訪問許可權順序public>預設)

*  方法名稱必須相同

*  引數列表必須相同

*  返回值為基本型別時必須相同

*  返回值為引用型別時相同或子類小(瞭解)

*/

public class Fu {

public void method(){

System.out.println(" 父類方法");

}

public int sum(){

return 0;

}

public Person get(){

return null;

}

}

public class Zi extends Fu{

//訪問許可權相同或子類方法訪問許可權更大(訪問許可權順序public>預設)

@Override

public void method(){

System.out.println("子類方法");

}

//返回值為基本型別時必須相同

@Override

public int sum(){

return 100;

}

//返回值為引用型別時相同或子類小(瞭解)

@Override

public Student get(){

return null;

}

}

第2章 抽象類

2.1 抽象類與抽象方法概念

抽象類用來描述一種型別應該具備的基本特徵與功能， 具體如何去完成這些行為由子類通過方法重寫來完成，如:

犬科均會吼叫，但屬於犬科的狼與狗其吼叫內容不同。所以犬科規定了有吼叫功能，但並不明確吼叫的細節。吼叫的細節應該由狼與狗這樣的犬科子類重寫吼叫的方法具體實現。

類似上邊犬科中的吼叫功能，並不明確實現細節但又需要宣告的方法可以使用抽象方法的方式完成。即抽象方法指只有功能宣告，沒有功能主體實現的方法。

具有抽象方法的類一定為抽象類。

那麼犬科就可以定義為抽象類，吼叫方法為抽象方法，沒有方法體。

2.2 抽象定義格式

抽象類定義的格式：

abstract在class前修飾類：

abstract class 類名 {

}

抽象方法定義的格式：

abstract在訪問許可權後，返回值型別前修飾方法，方法沒有方法體:

public abstract 返回值型別 方法名(引數);

看如下程式碼：

//員工

abstract class Employee{

public abstract void work();//抽象函式。需要abstract修飾，並分號;結束

}

//講師

class Teacher extends Employee {

public void work() {

System.out.println("正在講解Java");

}

}

//助教

class Assistant extends Employee {

public void work() {

System.out.println("正在輔導學生");

}

}

//班主任

class Manager extends Employee {

public void work() {

System.out.println("正在管理班級");

}

}

2.3 抽象類&抽象方法的使用

抽象類無法直接建立物件，只能被子類繼承後，建立子類物件。

子類需要繼承抽象父類並完成最終的方法實現細節(即重寫方法，完成方法體)。而此時，方法重寫不再是加強父類方法功能，而是父類沒有具體實現，子類完成了具體實現，我們將這種方法重寫也叫做實現方法。

2.4 抽象類注意事項

• 抽象類的意義

抽象類往往用來表示對問題領域進行分析、設計中得出的抽象概念。其存在的意義在於其設計性、複用性與擴充套件性。

抽象類方便了具體類的定義。

抽象類僅是對功能和屬性的宣告，表示這類事物應該具備這些內容。限制程式設計師不能直接建立該抽象類物件，必須定義其子類才可使用。如我們可以聽一隻狼的叫聲，也可以聽一隻狗的叫聲，但是如果我們聽一隻犬科的叫聲就顯然不合適了。

• 抽象類繼承細節

只有覆蓋了抽象類中所有的抽象方法後，其子類才可以例項化。如果存留未實現的抽象方法則該子類仍為一個抽象類，無法建立物件。

抽象類不一定包含抽象方法。

抽象類可以有非抽象方法。

/*

* 犬科

*

* 行為

*  吼叫

*/

public abstract class Quan {

public abstract void houJiao();

public abstract void sleep();

public void eat(){

System.out.println("吃");

}

}

/*

* 抽象類的注意事項：

* 子類必須重寫父類的所有抽象方法，如果有抽象方法沒有重寫，就相當於將抽象方法繼承過來，子類裡面有抽象方法，

* 有抽象方法的類必須是抽象類，子類也得定義為抽象類

*

* 抽象類不一定包含抽象方法。

* 抽象類可以有非抽象方法。

*/

public class Dog extends Quan{

public void eat(){

System.out.println("狗吃肉");

}

@Override

public void houJiao() {

System.out.println("狗汪汪叫！");

}

@Override

public void sleep() {

System.out.println("趴著睡");  

}

}

public class Test {

public static void main(String[] args) {

//抽象類不能建立物件

//Quan q = new Quan();

//可以建立子類物件

Dog d = new Dog();

d.houJiao();

}

}

第3章 綜合案例---動物類系列定義

3.1 案例介紹與演示

題目要求：

設計抽象父類與具體子類。

動物類：

屬性：年齡、姓名

方法：吃飯、睡覺

貓科類：

動物類基礎上新增產地

新增抓老鼠的方法

波斯貓、巴釐貓、卡通貓與貓科類類似

犬科：

與貓科類類似

3.1.1 案例分析

對於動物類與犬科貓科，均為抽象的概念，規定了該種類型體系中所應該具備的通用基本功能與屬性。而實際生產中不會建立動物、犬科、貓科的物件，而會使用更為具體的實現類物件。

定義抽象類動物、犬科、貓科。

定義該三種類型的具體子類。

在測試類中，測試子類屬性與子類方法。

/*

* 自定義資料型別  動物類

*

* 屬性

* 年齡  姓名

* 行為        

*  吃飯   睡覺

*/

public abstract class Animal {

private String name;

private int age;

//吃

public abstract void eat();

//睡

public abstract void sleep();

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

public abstract class Cat extends Animal{

private String address;

public  void catchMouse(){

System.out.println("抓老鼠！");

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

}

public class KTCat extends Cat{

@Override

public void eat() {

System.out.println("卡通貓吃卡通魚！");  

}

@Override

public void sleep() {

System.out.println("卡通貓站著睡");  

}

}

public class Test {

public static void main(String[] args) {

KTCat kt = new KTCat();

kt.setName("kitty");

kt.setAge(2);

kt.eat();

kt.sleep();

kt.catchMouse();

System.out.println(kt.getName());

System.out.println(kt.getAge());;

}

}

第4章 本日自習作業：

4.1 知識點相關題

4.1.1 什麼是繼承？繼承有什麼好處？

繼承是面向物件最顯著的一個特性。繼承是從已有的類中派生出新的類，新的類能吸收已有類的資料屬性和行為，並能擴充套件新的能力。Java繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的資料或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。這種技術使得複用以前的程式碼非常容易，能夠大大縮短開發週期，降低開發費用。

好處：

（1）繼承關係是傳遞的。若類C繼承類B，類B繼承類A（多層繼承），則類C既有從類B那裡繼承下來的屬性與方法，也有從類A那裡繼承下來的屬性與方法，還可以有自己新定義的屬性和方法。繼承來的屬性和方法儘管是隱式的，但仍是類C的屬性和方法。繼承是在一些比較一般的類的基礎上構造、建立和擴充新類的最有效的手段。

（2）繼承簡化了人們對事物的認識和描述，能清晰體現相關類間的層次結構關係。

（3）繼承提供了軟體複用功能。若類B繼承類A，那麼建立類B時只需要再描述與基類(類A)不同的少量特徵(資料成員和成員方法)即可。這種做法能減小程式碼和資料的冗餘度，大大增加程式的重用性。

（4）繼承通過增強一致性來減少模組間的介面和介面，大大增加了程式的易維護性。

（5）提供多重繼承機制。從理論上說，一個類可以是多個一般類的特殊類，它可以從多個一般類中繼承屬性與方法，這便是多重繼承。Java出於安全性和可靠性的考慮，僅支援單重繼承，而通過使用介面機制來實現多重繼承。

4.1.2 子類可以訪問父類的私有成員變數麼？

1.關於私有成員變數

     無論父類中的成員變數是pirvate、public、還是其它型別的，子類都會擁有（繼承）父類中的這些成員變數。但是父類中的私有成員變數，無法在子類中直接訪問，可以通過從父類中繼承得到的protected、public方法（如getter、setter方法）來訪問。

個人認為這更好的提現了JAVA特性中的封裝，而且符合軟體工程的設計思想：低耦合

2. 關於靜態成員變數

     無論父類中的成員變數是靜態的、還是非靜態的，子類都會擁有父類中的這些成員變數。

3. 關於被子類覆蓋的成員變數

無論父類中的成員變數是否被子類覆蓋，子類都會擁有父類中的這些成員變數。

4.1.3 繼承後沒有方法重寫可以麼？如果不可以說出原因，如果可以，是否有意義，為什麼。

抽象類中的非抽象方法不用重寫，其他必須重寫，介面的方法必須重寫；

介面和抽象類中只有方法名，沒有定義的，如果你不定義 也就是空方法，介面就是為了彌補java不能多重繼承，介面針對的是物件而不是實現。實現的部分可以交由物件去實現。這就是java中的多型啊。

4.1.4 方法重寫的注意事項有哪些？

方法重寫與方法過載不同，方法的過載是方法的引數個數或種類或順序不同，方法名相同。

方法重寫是要注意許可權的問題，子類中的許可權不能小於父類的許可權，當父類的許可權為private時，子類無法繼承。也就無法產生所謂的重寫。（修飾符高低：private < 預設修飾符 < public）

4.1.5 抽象方法是什麼，其格式是什麼，有什麼用？

java中的抽象方法就是以abstract修飾的方法，這種方法只宣告返回的資料型別、方法名稱和所需的引數，沒有方法體，也就是說抽象方法只需要宣告而不需要實現。

格式：

abstract在訪問許可權後，返回值型別前修飾方法，方法沒有方法體:

public abstract 返回值型別 方法名(引數);

作用：

抽象方法的作用是,你在此類裡不必實現它,只是一個虛方法,所有的實現可以到繼承此類的子類裡面去做.你也可以理解為,抽象方法就是用來被過載的方法.你可以在子類裡對它進行過載,也可以不進行過載.舉個例就象定義了一個電器類,其中一個虛方法是顯示圖象.你用電視機繼承電器類的時候就把顯示圖象的方法實現為電視機的顯示方法,用mp4繼承電器類時就把這個虛方法實現為mp4自己的顯示方法.如果是用收音機類去繼承電器,你就可以不用實現這個方法.

4.1.6 抽象類存在的意義是什麼？

抽象類的意義

抽象類往往用來表示對問題領域進行分析、設計中得出的抽象概念。其存在的意義在於其設計性、複用性與擴充套件性。

抽象類方便了具體類的定義。

抽象類僅是對功能和屬性的宣告，表示這類事物應該具備這些內容。限制程式設計師不能直接建立該抽象類物件，必須定義其子類才可使用。如我們可以聽一隻狼的叫聲，也可以聽一隻狗的叫聲，但是如果我們聽一隻犬科的叫聲就顯然不合適了。

4.1.7 類比課上案例，完成以下需求的類設計(已打亂子父類順序給出需求)，並建立物件，呼叫具體方法：

經理類：

姓名、年齡、薪水、獎金

吃飯、工作內容為管理員工，計算績效

人類：

姓名、年齡

吃飯

廚師類：

姓名、年齡、薪水、獎金

吃飯、工作內容炒菜

員工類

姓名、年齡、薪水

吃飯、工作

服務員類：

姓名、年齡、薪水、獎金

吃飯、工作內容端盤子

4.1.8 構造器Constructor是否可被override?

構造器Constructor不能被繼承，因此不能重寫Override，但可以被過載Overload。

4.1.9 下面選項正確的是：

.//設有下面兩個類的定義。

class Person {   long id;     // 身份證號 String name; // 姓名 }   class Student extends Person{ int score; int getScore(){ return score; } }

則類Person和類Student的關係是？

A.包含關係 B.繼承關係 C.關聯關係 D.上述類定義有語法錯誤

答案：B

4.1.10 下面選項正確的是：

A.子類繼承父類的所有屬性和方法

B.子類可以繼承父類的私有的屬性和方法

C子類可以繼承父類的公有的屬性和方法

D.建立子類物件時，父類的構造方法都要被執行

答案:C

4.1.11 下列敘述中錯誤的是？

A.一個子類可有多個父類

B.父類派生出子類

C.子類繼承父類

D.子類只能有一個父類

答案：A

4.2 程式碼題

4.2.1 門類繼承題

要求：

編寫程式碼，實現如下功能：

（1）定義一個門類，

包含3個屬性：寬度width 和 高度height ，顏色color

 包含2個方法：開門和關門

開門方法：輸出“門已經開啟，請進！”

關門方法：輸出“門已經關閉，禁止進入！”

（2）定義一個木頭門WOOD，繼承Door

重寫父類開門方法：輸出門的高度  寬度  顏色  +“門已經開啟，請進！”

重寫父類關門方法：輸出門的高度  寬度  顏色  +“門已經關閉，禁止進入！”

（3）定義一個測試類，測試類定義一個main方法

分別建立 門物件  和 木頭門物件， 為建立的木頭門物件屬性賦值, 呼叫開門和關門兩個方法。

答案：

public class Demo { public static void main(String[] args) { //建立門物件 Door door = new Door(); // 呼叫方法 door.openDoor(); door.closeDoor(); //  建立木頭門物件        WoodDoor woodDoor = new WoodDoor(); //呼叫set方法對屬性賦值 woodDoor.setWidth(1.8); woodDoor.setHight(2.5); woodDoor.setColor("紅色"); //  呼叫方法 woodDoor.openDoor(); woodDoor.closeDoor(); } } class Door { // 定義屬性 private double width; private double hight; private String color; public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } //開門方法 public void openDoor(){ System.out.println("門已經開啟，請進！"); } //關門方法 public void closeDoor(){ System.out.println("門已經關閉，禁止進入！"); } } class WoodDoor extends Door{ //重寫開門方法 public void openDoor(){ System.out.println("門的寬度為："+ getWidth() +"，高度為："+getHight()+"， 顏色："+getColor()+"，門已經開啟，請進！"); } //關門方法 public void closeDoor(){ System.out.println("門的寬度為："+ getWidth() +"，高度為："+getHight()+"， 顏色："+getColor()+"，門已經關閉，禁止進入！"); } }

4.2.2 動物類方法重寫

要求：

1.定義動物類，有名稱和年齡兩個屬性，且屬性私有化，提供相應的getXxx與setXxx方法，提供無引數的無返回值的吃飯方法，內容為：“吃飯...”；

2.定義貓類，繼承動物類，重寫父類中的吃飯方法，內容為：“貓吃魚...”

3.定義狗類，繼承動物類，重寫父類中的吃飯方法，內容為：“狗吃骨頭...”

4.定義測試類，分別建立貓物件和狗物件，並分別給父類物件中的名稱和年齡屬性賦值；

5.分別使用貓物件和狗物件獲取名稱和年齡的屬性值並列印在控制檯上；

6.分別使用貓物件和狗物件呼叫吃飯方法；

答案：

/* * 動物類： * 屬性： *  名稱 *  年齡 * 方法： *  吃飯方法 *  getXxx與setXxx */ public class DongWu { //屬性 private String name; private int age; //getXxx與setXxx public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //吃飯方法 public void chiFan(){ System.out.println("吃飯..."); } } /* * 狗類繼承動物類 */ public class Gou extends DongWu{ public void chiFan() { System.out.println("狗吃骨頭..."); } } /* * 貓類繼承動物類： */ public class Mao extends DongWu{ //重寫吃飯的方法； public void chiFan() { System.out.println("貓吃魚..."); } } /* * 測試類 */ public class Test { public static void main(String[] args) { //1、分別建立貓物件和狗物件，並分別給父類物件中的名稱和年齡屬性賦值 Mao m = new Mao(); m.setName("波斯貓"); m.setAge(3); Gou g = new Gou(); g.setName("哈巴狗"); g.setAge(2); //2、分別使用貓物件和狗物件獲取名稱和年齡的屬性值並列印在控制檯上； String name = m.getName(); int age = m.getAge(); String name2 = g.getName(); int age2 = g.getAge(); System.out.println("貓的名字為："+name+";年齡為："+age); System.out.println("狗的名字為："+name2+";年齡為："+age2); //3、分別使用貓物件和狗物件呼叫吃飯方法 m.chiFan(); g.chiFan(); } }