第8天面向物件

今日內容介紹
 繼承
 抽象類

第1章 繼承

1.1 繼承的概念

在現實生活中，繼承一般指的是子女繼承父輩的財產。在程式中，繼承描述的是事物之間的所屬關係，通過繼承可以使多種事物之間形成一種關係體系。例如公司中的研發部員工和維護部員工都屬於員工，程式中便可以描述為研發部員工和維護部員工繼承自員工，同理，JavaEE工程師和Android工程師繼承自研發部員工，而維網路維護工程師和硬體維護工程師繼承自維護部員工。這些員工之間會形成一個繼承體系，具體如下圖所示。

圖1-1 員工繼承關係圖
在Java中，類的繼承是指在一個現有類的基礎上去構建一個新的類，構建出來的新類被稱作子類，現有類被稱作父類

，子類會自動擁有父類所有可繼承的屬性和方法。

1.2 繼承的格式&使用

在程式中，如果想宣告一個類繼承另一個類，需要使用extends關鍵字。

格式：
class 子類 extends 父類 {}

接下來通過一個案例來學習子類是如何繼承父類的，如下所示。Example01.java

/*
 * 定義員工類Employee
 */
class Employee {
	String name; // 定義name屬性
	// 定義員工的工作方法
	public void work() {
		System.out.println("盡心盡力地工作");
	}
}

/*
 * 定義研發部員工類Developer 繼承 員工類Employee
 */
class Developer extends Employee {
	// 定義一個列印name的方法
	public void printName() {
		System.out.println("name=" + name);
	}
}

/*
 * 定義測試類
 */
public class Example01 {
	public static void main(String[] args) {
		Developer d = new Developer(); // 建立一個研發部員工類物件
		d.name = "小明"; // 為該員工類的name屬性進行賦值
		d.printName(); // 呼叫該員工的printName()方法
		d.work(); // 呼叫Developer類繼承來的work()方法
	}
}
 

執行結果如下圖所示。

圖1-2 執行結果
在上述程式碼中，Developer類通過extends關鍵字繼承了Employee類，這樣Developer類便是Employee類的子類。從執行結果不難看出，子類雖然沒有定義name屬性和work()方法，但是卻能訪問這兩個成員。這就說明，子類在繼承父類的時候，會自動擁有父類的成員。

1.3 繼承的好處&注意事項

繼承的好處：
1、繼承的出現提高了程式碼的複用性，提高軟體開發效率。
2、繼承的出現讓類與類之間產生了關係，提供了多型的前提。
在類的繼承中，需要注意一些問題，具體如下：
 1、在Java中，類只支援單繼承，不允許多繼承

，也就是說一個類只能有一個直接父類，例如下面這種情況是不合法的。

class A{} 
     class B{}
     class C extends A,B{}  // C類不可以同時繼承A類和B類

 2、多個類可以繼承一個父類，例如下面這種情況是允許的。

     class A{}
     class B extends A{}
     class C extends A{}   // 類B和類C都可以繼承類A

 3、在Java中，多層繼承是可以的，即一個類的父類可以再去繼承另外的父類，例如C類繼承自B類，而B類又可以去繼承A類，這時，C類也可稱作A類的子類。下面這種情況是允許的。

  class A{}
     class B extends A{}   // 類B繼承類A，類B是類A的子類
     class C extends B{}   // 類C繼承類B，類C是類B的子類，同時也是類A的子類

 4、在Java中，子類和父類是一種相對概念，也就是說一個類是某個類父類的同時，也可以是另一個類的子類。例如上面的這種情況中，B類是A類的子類，同時又是C類的父類。

1.4 繼承-子父類中成員變數的特點

瞭解了繼承給我們帶來的好處，提高了程式碼的複用性。繼承讓類與類或者說物件與物件之間產生了關係。那麼，當繼承出現後，類的成員之間產生了那些變化呢？

類的成員重點學習成員變數、成員方法的變化。

成員變數：如果子類父類中出現不同名的成員變數，這時的訪問是沒有任何問題。
看如下程式碼：

class Fu
{
	//Fu中的成員變數。
	int num = 5;
}
class Zi extends Fu
{
	//Zi中的成員變數
	int num2 = 6;
	//Zi中的成員方法
	public void show()
	{
		//訪問父類中的num
		System.out.println("Fu num="+num);
		//訪問子類中的num2
		System.out.println("Zi num2="+num2);
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(); //建立子類物件
		z.show(); //呼叫子類中的show方法
	}
}

程式碼說明：Fu類中的成員變數是非私有的，子類中可以直接訪問，若Fu類中的成員變數私有了，子類是不能直接訪問的。

當子父類中出現了同名成員變數時，在子類中若要訪問父類中的成員變數，必須使用關鍵字super來完成。super用來表示當前物件中包含的父類物件空間的引用。super今天不做具體講解，在第12天會詳細講解。

在子類中，訪問父類中的成員變數格式：

super.父類中的成員變數

看如下程式碼：

class Fu
{
	//Fu中的成員變數。
	int num = 5;
}
class Zi extends Fu
{
	//Zi中的成員變數
	int num = 6;
	void show()
	{
		//子父類中出現了同名的成員變數時
		//在子類中需要訪問父類中非私有成員變數時，需要使用super關鍵字
		//訪問父類中的num
		System.out.println("Fu num="+super.num);
		//訪問子類中的num2
		System.out.println("Zi num2="+this.num);
	}
}
class Demo5 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(); //建立子類物件
		z.show(); //呼叫子類中的show方法
	}
}

1.5 繼承-子父類中成員方法特點-重寫&應用

 子父類中成員方法的特點
當在程式中通過物件呼叫方法時，會先在子類中查詢有沒有對應的方法，若子類中存在就會執行子類中的方法，若子類中不存在就會執行父類中相應的方法。
看如下程式碼：

class Fu{
	public void show(){
		System.out.println("Fu類中的show方法執行");
	}
}
class Zi extends Fu{
	public void show2(){
		System.out.println("Zi類中的show2方法執行");
	}
}
public  class Test{
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show(); //子類中沒有show方法，但是可以找到父類方法去執行
		z.show2();
	}
}

 成員方法特殊情況——覆蓋
子類中出現與父類一模一樣的方法時，會出現覆蓋操作，也稱為override重寫、複寫或者覆蓋。

class Fu
{
	public void show()
	{
		System.out.println("Fu show");
	}
}
class Zi extends Fu
{
	//子類複寫了父類的show方法
	public void show()
	{
		System.out.println("Zi show");
	}
}

 方法重寫（覆蓋）的應用：
當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法，這樣，即沿襲了父類的功能，又定義了子類特有的內容。
舉例：比如手機，當描述一個手機時，它具有發簡訊，打電話，顯示來電號碼功能，後期由於手機需要在來電顯示功能中增加顯示姓名和頭像，這時可以重新定義一個類描述智慧手機，並繼承原有描述手機的類。並在新定義的類中覆蓋來電顯示功能，在其中增加顯示姓名和頭像功能。

在子類中，訪問父類中的成員方法格式：
super.父類中的成員方法();

看如下程式碼：

public class Test {
	public static void main(String[] args) {
		new NewPhone().showNum();
	}
}

//手機類
class Phone{
	public void sendMessage(){
		System.out.println("發簡訊");
	}
	public void call(){
		System.out.println("打電話");
	}
	public void showNum(){
		System.out.println("來電顯示號碼");
	}
}

//智慧手機類
class NewPhone extends Phone{
	
	//覆蓋父類的來電顯示號碼功能，並增加自己的顯示姓名和圖片功能
	public void showNum(){
		//呼叫父類已經存在的功能使用super
		super.showNum();
		//增加自己特有顯示姓名和圖片功能
		System.out.println("顯示來電姓名");
		System.out.println("顯示頭像");
	}
}

1.6 方法重寫的注意事項

重寫需要注意的細節問題：
 子類方法覆蓋父類方法，必須要保證許可權大於等於父類許可權。

class Fu(){	
void show(){}
    public void method(){}
}
class Zi() extends Fu{
public void show(){}  //編譯執行沒問題
    void method(){}      //編譯錯誤
}

 寫法上稍微注意:必須一模一樣:方法的返回值型別 方法名 引數列表都要一樣。
總結：當一個類是另一個類中的一種時，可以通過繼承，來繼承屬性與功能。如果父類具備的功能內容需要子類特殊定義時，進行方法重寫。

---

第2章 抽象類

2.1 抽象類-產生

當編寫一個類時，我們往往會為該類定義一些方法，這些方法是用來描述該類的功能具體實現方式，那麼這些方法都有具體的方法體。
但是有的時候，某個父類只是知道子類應該包含怎麼樣的方法，但是無法準確知道子類如何實現這些方法。比如一個圖形類應該有一個求周長的方法，但是不同的圖形求周長的演算法不一樣。那該怎麼辦呢？
分析事物時，發現了共性內容，就出現向上抽取。會有這樣一種特殊情況，就是方法功能宣告相同，但方法功能主體不同。那麼這時也可以抽取，但只抽取方法宣告，不抽取方法主體。那麼此方法就是一個抽象方法。(看不懂的話就多讀兩邊)
例子：
描述JavaEE工程師：行為：工作。
描述Android工程師：行為：工作。

JavaEE工程師和Android工程師之間有共性，可以進行向上抽取。抽取它們的所屬共性型別：研發部員工。由於JavaEE工程師和Android工程師都具有工作功能，但是他們具體工作內容卻不一樣。這時在描述研發部員工時，發現了有些功能（工作）不具體，這些不具體的功能，需要在類中標識出來，通過java中的關鍵字abstract(抽象)。
當定義了抽象函式的類也必須被abstract關鍵字修飾，被abstract關鍵字修飾的類是抽象類。

2.2 抽象類&抽象方法的定義

抽象方法定義的格式：

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

抽象類定義的格式：

abstract class 類名 {
}
看如下程式碼：
//研發部員工 
abstract class Developer {
	public abstract void work();//抽象函式。需要abstract修飾，並分號;結束
}

//JavaEE工程師
class JavaEE extends Developer{
	public void work() {
		System.out.println("正在研發淘寶網站");
	}
}

//Android工程師
class Android extends Developer {
	public void work() {
		System.out.println("正在研發淘寶手機客戶端軟體");
	}
}

2.3 抽象類的特點：

1、抽象類和抽象方法都需要被abstract修飾。抽象方法一定要定義在抽象類中。
2、抽象類不可以直接建立物件，原因：呼叫抽象方法沒有意義。
3、只有覆蓋了抽象類中所有的抽象方法後，其子類才可以建立物件。否則該子類還是一個抽象類。
之所以繼承抽象類，更多的是在思想，是面對共性型別操作會更簡單。

2.4 抽象類的細節問題：

1、抽象類一定是個父類？

	是的，因為不斷抽取而來的。所以被繼承後若想不再是抽象類就可以重寫（覆蓋）它裡面的所有抽象方法。

2、抽象類中是否可以不定義抽象方法。

是可以的，那這個抽象類的存在到底有什麼意義呢？不讓該類建立物件,方法可以直接讓子類去使用

3、抽象關鍵字abstract不可以和哪些關鍵字共存？

1、private：私有的方法子類是無法繼承到的，也不存在覆蓋，而abstract和private一起使用修飾方法，abstract既要子類去實現這個方法，而private修飾子類根本無法得到父類這個方法。互相矛盾。
2、final，暫時不關注，後面學
3、static，暫時不關注，後面學

---

第3章 綜合案例—員工類系列定義

3.1 案例介紹

某IT公司有多名員工，按照員工負責的工作不同，進行了部門的劃分（研發部員工、維護部員工）。研發部根據所需研發的內容不同，又分為JavaEE工程師、Android工程師；維護部根據所需維護的內容不同，又分為網路維護工程師、硬體維護工程師。
公司的每名員工都有他們自己的員工編號、姓名，並要做它們所負責的工作。
 工作內容

JavaEE工程師：員工號為xxx的 xxx員工，正在研發淘寶網站
 Android工程師：員工號為xxx的 xxx員工，正在研發淘寶手機客戶端軟體
 網路維護工程師：員工號為xxx的 xxx員工，正在檢查網路是否暢通
 硬體維護工程師：員工號為xxx的 xxx員工，正在修復印表機

請根據描述，完成員工體系中所有類的定義，並指定類之間的繼承關係。進行XX工程師類的物件建立，完成工作方法的呼叫。

3.2 案例分析

 根據上述部門的描述，得出如下的員工體系圖

 根據員工資訊的描述，確定每個員工都有員工編號、姓名、要進行工作。則，把這些共同的屬性與功能抽取到父類中（員工類），關於工作的內容由具體的工程師來進行指定。
 工作內容

JavaEE工程師：員工號為xxx的 xxx員工，正在研發淘寶網站
 Android工程師：員工號為xxx的 xxx員工，正在研發淘寶手機客戶端軟體
 網路維護工程師：員工號為xxx的 xxx員工，正在檢查網路是否暢通
 硬體維護工程師：員工號為xxx的 xxx員工，正在修復印表機

建立JavaEE工程師物件，完成工作方法的呼叫

3.3 案例程式碼實現

 根據員工體系圖，完成類的定義

定義員工類(抽象類)

    public abstract class Employee {
	private String id;// 員工編號
	private String name; // 員工姓名

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

//工作方法（抽象方法）

public abstract void work(); 
}

定義研發部員工類Developer 繼承 員工類Employee

public abstract class Developer extends Employee {
}

定義維護部員工類Maintainer 繼承 員工類Employee

public abstract class Maintainer extends Employee {
}

定義JavaEE工程師 繼承 研發部員工類，重寫工作方法

public class JavaEE extends Developer {
	@Override
	public void work() {
		System.out.println("員工號為 " + getId() + " 的 " + getName() + " 員工，正在研發淘寶網站");
	}
}

定義Android工程師 繼承 研發部員工類，重寫工作方法

public class Android extends Developer {
	@Override
	public void work() {
		System.out.println("員工號為 " + getId() + " 的 " + getName() + " 員工，正在研發淘寶手機客戶端軟體");
	}
}

定義Network網路維護工程師 繼承 維護部員工類，重寫工作方法

public class Network extends Maintainer {
	@Override
	public void work() {
		System.out.println("員工號為 " + getId() + " 的 " + getName() + " 員工，正在檢查網路是否暢通");
	}
}

定義Hardware硬體維護工程師 繼承 維護部員工類，重寫工作方法

public class Hardware extends Maintainer {
	@Override
	public void work() {
		System.out.println("員工號為 " + getId() + " 的 " + getName() + " 員工，正在修復印表機");
	}
}

在測試類中，建立JavaEE工程師物件，完成工作方法的呼叫

public class Test {
	public static void main(String[] args) {
		//建立JavaEE工程師員工物件
		JavaEE ee = new JavaEE();
		//設定該員工的編號
		ee.setId("000015");
		//設定該員工的姓名
		ee.setName("小明");
		//呼叫該員工的工作方法
		ee.work();
	}
}

---

第4章 總結

4.1 知識點總結

 繼承：是指在一個現有類的基礎上去構建一個新的類，構建出來的新類被稱作子類，現有類被稱作父類，子類會自動擁有父類所有
 繼承的好處：可繼承的屬性和方法。

提高了代表的可維護性
提高了程式碼的複用性
讓類與類之間產生了繼承關係
 繼承的弊端：
類與類之間的耦合度過高
 繼承特點：
java中類只能夠單繼承，不能多繼承，可以多層繼承
class Yy extends Object {}
class Fu extends Yy{}
class Zi extends Fu {}
所有的類都直接或者間接的繼承了 Object類，Object類稱為祖宗類
 繼承的注意事項：
1，使用關鍵字 extends 讓類與類之間 產生繼承關係
2, 父類私有的成員，子類不能繼承，因為根本看不到
3，不能為了繼承某個功能而隨意進行繼承操作， 必須要符合 is a 的關係
蘋果 is a 水果
男人 is a 人
狗 is a 人 ， 這種情況就不能繼承了
 繼承中的成員變數關係：
1,不同名的變數：
子類直接繼承使用
2,同名的變數：
預設訪問的是子類自己的成員變數, 想訪問父類中的同名變數，請使用 super.成員變數;
 繼承中的成員方法關係：
不同名的方法：

子類直接繼承使用

同名的方法：

預設訪問的是子類自己的成員方法，想訪問父類中的同名方法，請使用 super.成員方法();

 super:用來表示當前物件中包含的父類物件空間的引用
呼叫父類的成員變數：
super.成員變數;
呼叫方法的成員方法:
super.成員方法();

方法重寫(override)：指 在子父類中，出現了方法宣告相同的情況，也叫做方法覆蓋，方法複寫
 方法重寫的注意事項：

1， 子類的方法宣告要與父類相同
2, 子類要重寫方法的方法，方法的許可權修飾符不能比父類的更低
 3, 父類私有的方法，子類不能夠進行方法重寫
`
 方法過載(overload)：指 在同一個類中，多個方法名稱相同，它們的引數列表不同(個數不同，資料型別不同)

 抽象
 抽象方法： 方法只有宣告部分，沒有方法體
 抽象類： 包含抽象方法的類，一定是抽象類
使用 abstract 修飾的類，是抽象類
 抽象類的特點:
1，抽象類與抽象方法都必須使用 abstract來修飾
2，抽象類不能直接建立物件
3，抽象類中可以有抽象方法，也可以沒有抽象方法
4，抽象類的子類:

	    a，實現了抽象方法的具體類
		b，抽象類

抽象類面試題：
1，抽象類中是否可以沒有抽象方法？如果可以，那麼，該類還定義成抽象類有意義嗎？為什麼？
可以沒有抽象方法，有意義，不會讓其他人直接建立該類物件