Java當中子類繼承父類的一些特點，和對象的一些特點

面向對象的本質就是把寫好的代碼複製來複制去，隱藏代碼和顯示代碼，執行的都是顯示的代碼，創建對象，就是複製代碼但是看不見，調用方法就是讓代碼能夠看見，或者間能夠看見

創建對象，複製代碼到創建對象的地方（看不見）

繼承—複製以前的代碼加一些代碼，或者寫一個名字一樣的代碼（重寫方法），當重寫後的代碼和之前父類的代碼優先執行重寫後的代碼。

重寫後的代碼相當於顯示，被重寫的代碼隱藏

創建多態，複製父類代碼和子類重寫父類的代碼，（子類父類共有的代碼）（子類的本質就是複製父類的代碼加一些東西，）

執行的依舊是顯示的代碼

俗話說的傳遞參數無非就是複製代碼後刪除原本的代碼，垃圾回收機制就是刪除原本的代碼，釋放空間

1、當子類繼承父類後子類當中會看不見的複製粘貼父類的屬性和方法

2、子類默認在子類的構造方法（有參無參都調用）當中調用父類的無參構造，也就是說明在子類的構造方法當中會默認通過super(); （看不見）來調用父類的無參構造方法

3、當繼承體系是這樣的，孫子類繼承父親，父親繼承爺爺，當實例化孫子的無參構造的時候，會默認調用父類的無參構造，執行順序是爺爺無參構造 - >父親無參構造 - >孫子無參構造

4、當實例化化孫子的有參構造的時候，默認並調用父類的無參構造和爺爺的無參構造，執行順序是這樣的
爺爺無參構造 - >父親無參構造 - > 孫子有參構造

5、如果想讓直接通過new 類名稱（參數）；的方式去調用父類的有參構造方法側需要通過子類當中（在第一行）super關鍵字來手動調用父類的有參構造，當調用了父類的有參構造之後就不會調用無參構造了

class AA {
	AA() {// 每辦法在子類裏面調用這個
		System.out.println("AAAA");
	}
	AA(String aa) {
		System.out.println(aa);
	}
}
class BB extends AA {
	// 老師這個刪了爲什麼會報錯
	// 這裏是不是沒有
	BB() {
		System.out.println("BBBBBB");
		System.out.println("---------------");
	}
	BB(String bb) {
		System.out.println(bb);
	}
}
class CC extends BB {
	CC() {
		System.out.println("-------------");
	}
	CC(String cc) {
		System.out.println(cc);
	}
}
public class Test02 {
	public static void main(String[] args) {
		CC c = new CC("aaaaaaaaaa");
	}
}

6、當實例化孫子的有參構造，並依次在孫子的有參構造和父親的有參構造當中通過super來調用父類的有參構造的時候，執行順序是，爺爺有參構造 - > 父親有參構造 -> 孫子有參構造

7、子類可以通過super來調用父類的方法來爲自己服務，當將對應的值通過super（參數）傳遞給父類的構造方法的時候，該值也會被子類所繼承，並可以直接使用

8、父類獲得到的值子類也會獲得到，即使是子類通過某種方式提交給父類，那麼這個值，子類父類同時都可以訪問到，也就是說子類傳遞到父類的屬性或者方法，可以通過子類調用父類方法的方式獲取到

9、也就是說明super調用的不是父類當中的方法和屬性，而調用的是子類繼承到父類的東西，也就是調用的是子類擁有父類的屬性，實際使用的還依舊是子類當中的屬性和方法，即使子類重寫父類的方法（使用多態會默認調用子類的方法），子類擁有父類當中的方法依舊存在，子類依舊可以調用該方法

10、子類重寫父類的方法，子類擁有父類的方法並不會被覆蓋，因爲在子類重寫父類方法之後依舊可以調用被重寫的方法，子類重寫父類方法實際上是複製一份父類的方法，只不過在執行的時候優先使用子類當中的方法

分別定義兩個類

public class Teacher {
	public String tname;
	public String tid;
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	public Teacher(String tname, String tid) {
		this.tname = tname;
		this.tid = tid;
	}
	public void work() {
		System.out.println(tname+tid);
	}
}

public class HuLiTeacher extends Teacher {
	String tkm;
	public HuLiTeacher() {
		// TODO Auto-generated constructor stub
	}
	public HuLiTeacher(String tname, String tid, String tkm) {
		super(tname, tid);
		this.tkm = tkm;
	}
	public void work() {
		super.work();// 但是這裏卻取不到上面賦予的值，這是怎麼回事啊
		System.out.println("老師科目" + tkm);
	}
}

子類繼承父類可以這樣理解

藍色沒有的（屬性和方法）紅色有的（屬性和方法）直接使用默認紅色，藍色也有的（屬性和方法）紅色也有的（屬性和方法），優先使用藍色，藍色有的（屬性和方法）紅色沒有的（屬性和方法）直接使用藍色，如果想要單獨調用需要通過this，或者super

也就是說super與其說是在調用父類的屬性和方法，還不如說是在調用這些隱藏的屬性和方法，

當創建子類對象或者本類使用屬性或方法的時候，子類當中有和隱藏的屬性和方法重名的時候，則優先使用的是子類當中的，如果都要使用則需要在子類當中通過super或者this來調用，都沒有的時候則默認調用的是隱藏的方法和屬性，或者不是隱藏的（選擇其一）。（表明看起來是調用了父類的方法和屬性）
也可以理解爲這樣

創建對象的過程也可以理解爲複製代碼的過程，複製之後看不到而言，通過創建引用的方式爲這段看不見的起名字，可以通過引用來調用看不見的代碼

多態

多態方法參數是對象的時候，可以理解爲接收復制的代碼是父類原本的代碼，和子類重寫的代碼，當做是父類的代碼來使用

創建多態可以理解爲這裏複製 的代碼 是父類繼承的屬性和方法（super）和子類重寫父類的屬性或方法 的代碼
如果重寫優先使用子類，父類的和子類重寫父類的

多態作用：把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫2113出通用的代碼，做出通用的編程，以適應需求的不斷變化。子類複製了父類的代碼，然後子類可以看做是父類的代碼，因爲多態使用的是他們公共的代碼。

賦值之後，父類型的引用就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行爲像兒子，而不是兒子的行爲像父親。

多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，就是同一種事物表現出的多種形態。編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。

如果只是創建子類對象可以理解爲複製的代碼是子類當中可以看到和從父類繼承看不到的代碼的全部代碼

方法當中的參數就相當於將代碼複製到當前方法當中，如果傳遞的子類那就把父類和子類共有的屬性和方法顯示

abstract的目的就是必須讓隱藏的代碼必須顯示出來用（方法或者屬性）提醒用戶使用，但是也是必須使用

單static 修飾就是代碼不能複製只能直接使用，可以修改

單finall 修飾意思就是代碼不能修改，可以複製，但是不可以被子類複製，因爲子類的本質就是修改
類和方法都不可以被複制，修改

static final 就是代碼不能複製也不能修改

子類無法重寫父類的靜態方法和final方法和private
但是可以繼承靜態方法，無法繼承final和private

子類無法重寫父類的靜態方法,因爲靜態方法只有一份，如果重寫另外一份靜態方法那就是另外一份靜態方法

int arr0[];// 創建數組不開闢空間

		arr0 = new int[18];// 開闢內存空間

		int arr1[] = new int[5];// 創建數組開闢內存空間 ,但是不賦值

		// 創建數組並同時開闢內存空間對其進行賦值
		int arr2[] = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10 };

		// 聲明引用和賦值，必須在同一句
		double arr3[] = { 2, 3, 4, 56, 5 };// 創建數組並同時開闢內存空間對其進行賦值

		for (int i = 0; i < arr3.length; i++) {
			System.out.println(arr3[i]);
		}

		for (int a : arr2) {
			System.out.println(a);
		}

public class Student {

	public int sid;
	public String sname;
	public int age;

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(int sid, String sname, int age) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.age = age;
	}

}

// 創建對象數組

		// 沒有複製代碼，只是齊了5個名字
		Student[] s = new Student[5];// 創建了存儲student引用的5個空間，但是沒有創建Student對象

		// 複製代碼到名字1
		s[0] = new Student(1, "張一", 17);// 創建對象將值賦予到對象數組的引用上，也就是讓數組當中的各個引用指向該對象
		s[1] = new Student(2, "張二", 15);// 創建對象將值賦予到對象數組的引用上，也就是讓數組當中的引用指向該對象
		s[2] = new Student(3, "張三", 18);// 創建對象將值賦予到對象數組的引用上，也就是讓數組當中的引用指向該對象
		s[3] = new Student(6, "張四", 32);// 創建對象將值賦予到對象數組的引用上，也就是讓數組當中的引用指向該對象
		s[4] = new Student(5, "張無", 45);// 創建對象將值賦予到對象數組的引用上，也就是讓數組當中的引用指向該對象

		for (int i = 0; i < s.length; i++) {

			System.out.print(s[i].sid);
			System.out.print(s[i].sname);
			System.out.println(s[i].age);

		}

		String[] s2 =  {"aaaa","sasasas"};
		
		for (int i = 0; i < s2.length; i++) {
			System.out.println(s2[i]);
		}

字符串直接賦值通過雙等號比較的時候比較的是值（但是實際上也是比較的地址，只不過這個時候是一個內存空間）
按值傳遞複製的是值
按引用傳遞傳遞的是代碼
字符串在創建對象new 的時候通過雙等號比較兩個字符串是比較的是地址值

如果父類沒有無參構造方法，那麼子類的構造方法會出現什麼現象呢?
報錯。
如何解決呢?
A:在父類中加一個無參構造方法
B:通過使用super關鍵字去顯示的調用父類的帶參構造方法
C:子類通過this去調用本類的其他構造方法
子類中一定要有一個去訪問了父類的構造方法，否則父類數據就沒有初始化
默認情況是自動訪問父類的無參構造，先創建父類，然後創建子類，如果父類沒有無參構造，就需要在子類的構造方法當中調用父類有參構造，來創建父類，然後纔是創建子類（先有父類後有子類）