繼承（extends）：
1.作用：為方法覆寫和多型機制做準備；使代碼得到復用（節省代碼量）；
2.格式： class 子類 extends 父類
3.理解繼承：子類繼承父類，其實就相當于把父類的類體中的所有代碼（除了構造方法）復制，粘貼到子類的類體里；
4.當一個類沒有繼承父類時，將默認繼承object類，object類為Java語言提供的“ 祖宗 ”類 “；Java中所有類都會直接 / 間接繼承object類，因為即使一個類繼承了其他父類，但是它的父類或者父類的父類...總會默認繼承object類吧；
5.super : 就一個有用的效果---在子類的構造方法中通過super呼叫上一個父類的構造來初始化屬性；
注意：1）super只能出現在構造方法的第一行；
2）當第一行我們沒有手動呼叫super時，系統會默認有一個“ super ( ) ”，目的是在呼叫子類構造方法時，先對父類屬性進行初始化；
3）不管咱在子類構造方法中調不呼叫super，super總會出現并起作用的，所以父類的無參構造方法一定不能少（否則獎勵報錯），在每一個類體中都把無參構造方法寫進去也是一個程式員必不可少的習慣；
4）this ( ) 與super ( ) 會沖突，不用細扣，反正 this 就是用來區分同名的形參和實體變數的，你寫在構造方法里干嘛，對吧；
輔助代碼理解：
class Animal{
int a;
String b;
public Animal() {
}
public Animal(int a, String b) {
this.a = a;
this.b = b;
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public void put(){
System.out.println(a+b);
}
}
class Panda extends Animal {
// int a;
// String b;
public Panda() {
}
public Panda(int a, String b) {
super(a, b);
}
// public int getA() {
// return a;
// }
// public void setA(int a) {
// this.a = a;
// }
// public String getB() {
// return b;
// }
// public void setB(String b) {
// this.b = b;
// }
// public void put(){
// System.out.println(a+b);
// }
}如上代碼：因為Panda類繼承了Animal類，所以Animal類中除構造方法以外的所有代碼（在Panda類體中被注釋的代碼）都復制粘貼到了Panda的類體中( 隱藏了)，所以說Panda類中看似只有倆個構造方法的代碼，但其實被注釋掉的代碼也相當于它的代碼；
注意：
1）Java中只支持單繼承，不支持多繼承，eg： class A extends S , Z ( 錯誤寫法) ；
2）除構造方法以外，子類會繼承父類中的所有代碼；
3）當我們修改了父類類體中的代碼（除構造方法外）時，那么直接繼承 / 間接繼承 它的類中的對應的代碼也會發生改變；
4）object類體中有一個方法名為“ toString ”，回傳值型別為“ String ”的方法，我們在主方法中創建一個物件后，再利用" System . out . print ( 參考 ) 就可以輸出“ toString ”中的回傳值；
方法覆寫；
1.作用物件；只會發生在有 直接繼承 / 間接繼承 關系的倆個類之間；
2.上面提到子類會將父類中除了構造方法以外的所有代碼都復制粘貼到子類中，那么粘貼過來的方法可不可以進行重寫呢？可以，但是注意：第一，訪問權限不能降低，只能升高；第二，回傳值型別不能改變；第三，方法名必須相同；第四，引數串列必須相同；
輔助理解代碼：
class Animal{
String a;
public Animal() {
}
public Animal(String a) {
this.a = a;
}
public void put(){
System.out.println("父類方法執行！");
}
public String toString(){
return "一種動物";
}
}
class Panda extends Animal {
public Panda() {
}
public Panda(String a) {
super(a);
}
//對父類中的 put 方法進行方法覆寫
public void put(){
System.out.println("我就不執行父類方法！我就執行我重寫的！");
}
//對父類中的 toString 方法進行方法覆寫
public String toString(){
return "一只熊貓";
}
}
public class pra{
public static void main(String[] args) {
Animal an=new Animal();
an.put();//呼叫此物件的 put 方法
System.out.println(an.toString());//輸出此物件的 toString 方法的回傳值
Panda pa=new Panda();
pa.put();//呼叫此物件重寫過的 put 方法
System.out.println(pa.toString());//輸出此物件重寫之后的 toString 方法的回傳值
}
}
----------------------------------------------
輸出結果；
父類方法執行！
一種動物
我就不執行父類方法！我就執行我重寫的！
一只熊貓
Process finished with exit code 0多型機制：
1.概念：使得同一個屬性或方法在父類及其各個子類中具有不同的含義；代碼體現：父類參考指向子型別物件；
2.Java程式分為編譯階段和運行階段，就” 通過子類的構造方法創建物件，并用父類的參考資料變數保存物件地址 “談談：
編譯階段，編譯器會到參考資料型別對應的父類中找（后面子類呼叫的）構造方法，找到了，靜態系結成功；運行階段，由于在堆記憶體創建的是子類的物件，所以運行階段系結的是子類的構造方法，動態系結成功；所以當用” 父類的參考 . “ 的方式呼叫方法時，實際執行的是子類中的（方法覆寫的）的方法，訪問屬性也是同理；
3.意義：提高程式的拓展性，降低耦合性；
輔助理解代碼；
class Master{
private String name;
private Pet pet;
public Master(){
}
public Master(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Pet getPet() {
return pet;
}
public void setPet(Pet pet) {
this.pet = pet;
}
public void feed(Pet pet){
pet.eat();
}
}
class Pet{
public Pet(){
}
public void eat(){
System.out.println("寵物在吃主人喂的食物");
}
}
class Dog extends Pet{
public Dog(){
}
public void eat(){
System.out.println("狗在吃主人喂的狗糧");
}
}
class Cat extends Pet{
public Cat(){
}
public void eat(){
System.out.println("貓在吃主人喂的貓糧");
}
}
//以后張三又喜歡養其他的寵物了，就不需要修改張三的feed方法(多型機制的好處)，只需再添加一個新寵物子類即可
public class 主人喂寵物 {
public static void main(String[] args){
Master M=new Master("張三");//創建主人物件-張三
Pet p1=new Dog();//創建寵物1(靜態系結) 狗(動態系結)---真正的物件
Pet p2=new Cat();//創建寵物2(靜態系結) 貓(動態系結)---真正的物件
M.setPet(p1);//將張三與小狗關聯起來（所屬關系）
M.feed(p1);//通過呼叫張三的的feed方法來喂小狗
M.setPet(p2);//將張三與小貓關聯起來（現在不養小狗了，養小貓了）
M.feed(p2);//通過呼叫張三的的feed方法來喂小貓
}
}
------------------------------------
輸出結果：
狗在吃主人喂的狗糧
貓在吃主人喂的貓糧
Process finished with exit code 0
隨筆：
1.引數串列：引數的個數，引數的種類，引數的順序（不以引數名為準），不包括引數名；
2.向上轉型：指的是將子類參考資料型別轉換為父類參考資料型別（類比自動型別轉換）；
3.向下轉型：指的是將父類參考資料型別轉換為子類參考資料型別（類比強制型別轉換）；
由于博主目前還沒有將 Java-SE 的知識都學完，所以有些地方可能說的有些片面，若前輩們能夠指點一二就更好了 （～￣(OO)￣)ブ
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/353114.html
標籤：Java
上一篇：音視頻處理、影像處理、影像識別和字符識別全能庫JavaCV完整教程（包含完整JavaCV入門、JavaCV實戰、ffmpeg、opencv和tesserac教程）
下一篇：面向物件