這次是2021年01月18日的學習成果，總結于此，以便于之后的學習查漏補缺

繼承

繼承是面向物件程式的一個基本特征，通過繼承可以實作父子關系，以及代碼的復用

繼承的作用

1、描述類和類之間的關系
2、降低類和類之間的重復代碼

extends 關鍵字

在類的宣告中，通過extends 關鍵字宣告一個繼承關系，java只支持單繼承，每個java只能有一個父類，
例如，下面的代碼中，Father是父類，Son是子類，二者之間有繼承關系：

public class Son extends Father{
}

Java類體系中的根類是java.lang.Object,所有類都是Object的直接子類或間接子類，如果定義類時沒有extends子句，則該類的父類默認為Object

instanceof

instanceof關鍵字用來判斷一個物件是否是指定類所創建的實體，回傳值是boolean

語法：
boolean flag = 物件 instanceof 類

示例：

Person person = new Person();
System.out.println(person instanceof Person);

方法重寫（重點）

在繼承中，子類可以定義和父類相同的名稱且引數串列一致的函式,將這種函式稱之為函式的重寫，簡而言之，重寫方法就是在子類中重新定義父類中已有的方法，

我們可以說:

1、多載是一個類中一個方法功能的多種表現形態
2、重寫是父子類對于同一個方法表現出不同的形式

1、重寫要求

1、在子類中的重寫方法和父類中的被重寫方法，兩個方法名稱和引數串列必須相同，

2、子類中重寫方法的訪問權限必須大于或等于父類中被重寫方法的訪問權限，否則編譯報錯，( public > protected > default > private )

3、子類中重寫方法的回傳值型別必須是父類中方法的回傳值型別或該型別的子類，不能回傳比父類更大范圍的資料型別，

4、子類中重寫方法不能比父類中被重寫方法產生更多的例外型別，

5、父類的建構式是不能子類繼承的，因此不能在子類中重寫，但是，在子類中可以使用super關鍵字訪問父類中的建構式，

2、重寫方法呼叫順序

1、子類中重寫后的方法在方法體的第一行默認呼叫父類被重寫的方法

//父類的方法
public class Father {
	public void buy(int money) {
		System.out.println("這是父類的buy方法"+money);
	} 
}

public class Son extends Father{
//子類中重寫后的方法
	@Override
	public void buy(int money) {
		super.buy(money); //默認呼叫，可洗掉
		System.out.println("這是子類的buy方法"+money);
	}
}

呼叫子類的buy方法，執行結果:

父類的buy方法:10
子類的buy方法:10

2、子類的物件呼叫重寫方法時依據就近原則優先呼叫子類重寫后的方法

3、子類中呼叫父類的方法

super.方法名()

3、方法重寫和多載的主要區別（重點）

重寫用于繼承關系的父子類中,不能用于同一個類中，

重寫用于更改父類中方法的行為，或者是實作介面中的方法，
重寫特點:函式名必須相同、引數串列必須相同，子類的回傳值型別要等于或者小于父類的回傳值等,子類的作用域不能小于父類中方法的作用域，子類拋出的例外型別不能大于父類中方法的例外型別，

多載通常用于同一個類中，多載用于為一個行為提供多種實作方式，
多載特點:函式名相同，引數串列不同，與訪問控制符、回傳值型別等無關，

建構式和super（重點）

1、super

super表示對當前物件的父類物件的一個參考，用于訪問父類的屬性，父類的方法和父類的構造方法，

public class Father {
	int x = 1;
	public Father() {
		System.out.println("這是父類的無參構造");
	}
	
	public Father(int x) {
		this.x = x;
		System.out.println("這是父類的有參構造");
	}

	public void speak() {
		System.out.println("這是父類的speak方法");
	} 
}

public class Son extends Father{
	int y = 1;
	public Son() {
		System.out.println("這是子類的無參構造");
	}

	public Son(int y) {
		this.y = y + x;	 //訪問父類屬性x，也可寫作super.x
		System.out.println("這是子類的有參構造");
	}
	
	public void run() {
		super.speak();	//顯示訪問父類的函式
		System.out.println("這是子類的run方法");
	}
}

public class Test1 {
	public static void main(String[] args) {
		Son son = new Son(2);
		System.out.println(son.y);  //輸出結果為3
	}
}

this和super小結

this和super很像，this指向當前物件，super指向當前物件的父類

2、建構式

**創建子類物件時，必須先初始化父類屬性,所以必須先執行父類的構造方法再執行子類構造方法，**經典理解:先有父親，才會有兒子，在Java的繼承體系中亦如此，

子類不能繼承父類的建構式,但子類建構式里必須先呼叫(隱式呼叫或顯式呼叫)父類的建構式，

(1)隱式呼叫父類建構式(默認情況)

在子類的建構式中，如果沒有顯示地呼叫父類中的建構式，那么默認會呼叫父類中的無參建構式，如果父類中沒有無參建構式則編譯報錯，

public class Father {
	public Father() {
		System.out.println("這是父類的無參建構式");
	}
}

public class Son extends Father{
	public Son() {
		super(); //默認呼叫父類的無參建構式
		System.out.println("這是子類的無參建構式");
	}
}

(2)顯示呼叫父類中建構式

如果在子類中使用super顯式呼叫父類中帶引數的建構式，那么編譯器不會呼叫父類中無參建構式的代碼，請注意:呼叫父類建構式的super只能放在子類的建構式的第一行，且只能呼叫一-次，

例如，在子類Son的建構式中使用super()呼叫父類的建構式，

public class Father {
	int x = 2;
	int y = 1;
	public Father(int y) {
		super();
		this.y = y;
	}
}

public class Son extends Father{
	int y = 2;
	public Son(int y) {
		super(y); //子類顯式呼叫父類建構式
		this.y = y + x;
		System.out.println("子類的有參建構式");
	}
}

注意：在同一建構式中，不能同時存在super()和this()，因為他們都要求放在建構式的第一行代碼

繼承特性總結

1、Java 只支持單繼承，不允許多重繼承;但是Java支持多層繼承

(1)、 一個子類只能有一個父類;只有唯一的親生父親
(2)、一個父類可以派生出多個子類;子孫滿堂
(3)、Java支持多層繼承;代代相傳
(4)、被繼承的類稱之為父類(基類)，繼承的類稱之為子類

2、子類可以繼承父類的非私有屬性和非私有方法

3、子類可以擴展父類沒有的屬性和方法

4、子類不會繼承父類的構造方法，

5、子類一定會呼叫父類的構造器，因為在創建子類物件時，一定會先為從父類繼承的屬性進行初始化，所以要呼叫父類的構造器

6、在子類中無論寫不寫super( )都會呼叫父類的無參構造，如果要寫，則必須在子類構造器首行，如果父類沒有無參構造，必須在子類的構造器首行使用super(實參串列)顯式呼叫父類的有參構造，否則編譯報錯;

7、不要為了使用繼承而繼承，例如:讓工人繼承學生，

8、當父類參考指向子類物件時:成員變數，靜態方法看左邊;非靜態方法:編譯看左邊，運行看右邊! ! !

final（重點）

final關鍵字主要用于修飾類、屬性、方法，以及方法的形參，final 在類之前，該類不能被繼承，final 在方法之前，該方法不可被重寫，final 在變數之前，該變數不可被修改，就是一個常量，

1、final修飾類

如果類沒有必要進行擴展，為了防止代碼功能被重寫，通常將類加final 修飾，這樣將限制該類不會有繼承的子類，如果撰寫了它的子類，編譯時就會報錯，

//這是一個final類，它不可被子類繼承
public final class FinalArcher {
}

2、final修飾成員屬性

常量定義

在變數之前使用final 修飾，就是定義一個常量，表示值不能被修改，

在實際專案中，該關鍵字一般和static關鍵字結合使用，這樣可以使常量優先加載，不必等到創建物件的時候再初始化，而且訪問時不需要事先創建物件實體，直接使用類名就可以訪問，

public class MathPI {
	//final和static可以互換位置
	public static final double PI = 3.14;
}

public class Test {
	public static void main(String[] args) {
		System.out.println(MathPI.PI);
	}
}

3、final修飾方法

如果父類中函式不想被子類繼承并重寫，可以將該函式使用final修飾

public final double add() {
		return 3.0;
	}

4、final修飾形參（輸入引數）

當形參被修飾為final，那么該形參在所屬方法中不能被修改

public static void print(final String[] arr) {
		//arr = null;無法重新賦值
	}

可見性

在Java語言中，常見的可見性有四種: public、private、 protected、 default (默認，即沒有定義) ;即訪問控制符，

類的成員的可見性

對類的成員變數和成員方法，我們可通過設定一定的訪問可見性來限定應用范圍，

小結

當使用訪問控制符修飾類的成員(包括成員變數、方法和構造器等)時

1、成員使用private修飾只在本類中使用，

2、public修飾的成員可以被所有類訪問

3、若一個成員沒有使用任何修飾符,默認為default;該成員可以被包中的其他類訪問，

4、被protected修飾的成員可以被包中其他類訪問,并且位于不同包中的子類也可訪問，

外部類的可見性

對于外部類(即目前學習的普通類)而言，它也可以使用訪問控制符修飾，但外部類只能有兩種訪問控制級別: public 和默認，成員內部類可以使用private，

public類可以被所有類訪問，即，使用public 修飾的外部類可以被所有類使用，如宣告變數、創建實體，

不使用任何訪問控制符修飾的外部類即被默認修飾性修飾的類,只能被同一個包中的其他類使用，

外部類不能使用private 和protected 修飾，因為外部類沒有處于任何類的內部，也就沒有其所在類的內部、所在類的子類兩個范圍，因此private和protected訪問控制符對外部類沒有意義，

抽象類（了解）

抽象類不能被直接實體化，因此它-.般作為其它類的父類，與final類正好相反，

1、語法

(1)抽象類

用abstract 關鍵字來修飾一個類時， 該類叫做抽象類，

//抽象類
public abstract class sheep { 
}

(2)抽象方法

用abstract 來修飾-一個 方法時，該方法叫做抽象方法，抽象方法只能在抽象類中定義，它只有方法宣告，沒有方法體，

public abstract class Sheep { 
	//抽象方法
	public abstract float area();
}

(3)抽象類特點

1、抽象類中不一定有抽象函式，

2、抽象方法只能在抽象類中定義，

3、抽象類不能直接創建實體，只能通過子類創建實體，

4、編譯器強制子類實作抽象父類中的抽象方法，如果子類也是抽象類則可以不實作，

介面（重點）

1、介面的引入

在C++中支持多重繼承實作，為了避免多重繼承的復雜性，Java 只支持單繼承，為了實作類似于多重繼承的效果，Java提供了介面來拓展類的功能，彌補Java中單繼承的缺點，

2、介面語法

(1)介面定義

介面就是抽象方法和常量值定義的集合，

public interface MyInterface extends MySuperInterface{
	//抽象屬性
	//抽象方法
}

注意:

1、關鍵字interface
2、介面中方法只有宣告，沒有定義(沒有方法體)
3、介面中的所有屬性:默認的修飾符是public static final
4、介面中的所有方法:默認的修飾符是public abstract

從本質上講，介面是一種特殊的抽象類,這種抽象類中只包含常量和方法的定義,而沒有變數和方法的實作，

(2)介面實作(重點)

類與類之間有繼承關系,那么介面與類之間又是什么關系呢?介面與類之間是實作關系，類實作介面用關鍵字implements,一個類可實作一個或多個介面;假若實作了多個介面，每個介面之間用逗號隔開，

單介面實作

public abstract class Sheep implements MyInterface{ 
}

多介面實作

利用介面可實作類似C++中多重繼承的效果，即一個類可以實作多個介面，在implements子句中用逗號分隔，

public class Sheep implements A,B{ 
	public void method1() {}
	public void method2() {}
}

介面繼承（了解）

介面是支持多重繼承的，即一個介面可以有多個父介面
例如，定義下列多個借口

	interface A{
		void menthod1();
	}
	interface B{
		void menthod2();
	}
	interface C{
		void menthod3();
	}

在MyInterface中繼承了介面A,B,C ，同時定義了method4：

public interface MyInterface extends A,B,C{
	void method4();
}

現在，在MyInterface中有四個方法，包括父介面的method1，method2，method3以及自身的method4

(4)總結

1、介面沒有構造方法，

2、介面中定義的所有屬性默認是public static final的，即靜態常量，

3、介面中定義的所有方法默認是public abstract的，即抽象方法，

4、由于介面中的定義的所有方法默認都是抽象的，所以介面不能被實體化，

5、有抽象函式的不一定是抽象類，也可以是介面，

6、類可以通過implements實作介面，一個類可以實作多個介面，

7、如果類沒有實作介面中的所有方法，那么類必須是抽象類，

8、如果在類中訪問介面中的屬性，不能使用super 關鍵字，因為兩者之間沒有顯示的繼承關系，可以使用 “介面名.屬性名” 直接訪問，

3、介面與抽象類(了解)

實作介面的類也可以是抽象類,這個類可以不實作介面中的方法，它把這些方法都作為自身的抽象方法，因此，在抽象類中可以不需要實作所有方法，可以留在子類中定義，

public abstract class Sheep implements MyInterface{ 
}

4、介面應用(重點)

例如, PencilWithEraser 繼承了Pencil 的 write 方法具備了寫功能,現在希望具備擦功能，由于Java只支持單繼承，無法繼承Eraser,因此無法具備擦功能，

現在，將 Eraser 定義為介面，從而擴展 PencilWithEraser 的功能，使其具備擦功能，具體實作如下:

鉛筆 類

public class Pencil {
	public String name;

	public Pencil() {
	
	}
	
	public Pencil(String name) {
		this.name = name;
	}
	
	public void write() {
		System.out.println("鉛筆寫字");
	}
}

介面，橡皮

public interface Eraser {
	public static final String color = "白色";
	public void clean();
}

帶橡皮的鉛筆 類繼承鉛筆類，實作橡皮介面

public class PencilWithEraser extends Pencil implements Eraser{
	public String name;
	public String type;
	public PencilWithEraser() {
	}

	public PencilWithEraser(String name) {
		super(name);
	}
	
	public PencilWithEraser(String name, String type) {
		super();
		this.name = name;
		this.type = type;
	}

	@Override
	public void write() {
		super.write();
		System.out.println(name+"考試專用");
	}

	@Override
	public void clean() {
		System.out.println("帶橡皮的鉛筆，就是好用");
	}	
}

測驗類

public class Test {
	public static void mian() {
		PencilWithEraser pencil = new PencilWithEraser("中華", "2B");
		pencil.write();
		pencil.clean();
		System.out.println(pencil.color);
		System.out.println(PencilWithEraser.color);
	}
}