一、什么是繼承
繼承就是子類繼承父類的特征和行為，使得子類物件（實體）具有父類的實體域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為，可以聯系生活進行理解，相當于父親和兒子的關系，父親有的屬性和能力在兒子身上都會有所體現，在java中，子類繼承了父類，就能使用父類的靜態屬性和動態方法，從而對事物進行抽象，
二、為什么需要繼承——【減少代碼量】
1、在程式開發中，會有很多模塊有相同或者相近的屬性和功能，如果為每一個模塊寫一遍，那代碼量將會成倍的增加，當將一些共有的代碼提煉出來，在需要的的地方進行使用，這就減少了不必要的代碼，當配合子類特有的屬性方法，就能滿足特定的功能需求，
2、使類與類之間產生了關系，有了這個關系，才有多型的特性，
三、繼承的實作
- 基本語法【使用extends關鍵字】：
修飾符 class ClassName extends extend_class { // 類體 } - 繼承的特性：
1、子類擁有父類非 private 的屬性、方法，
2、子類可以擁有自己的方法和屬性
3、java 的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是父類也可以繼承于其他類，
4、 - java繼承的簡單實體：
父類有屬性money，car，tall，name四個屬性，當被繼承時，這些屬性都可以在子類中直接訪問到，
public class Father { public int money=10_000_000; private int car=2; static double tall=178; protected String name="ThreePure"; public int getCar() { return car; } public void setCar(int car) { this.car = car; } public void say(){ System.out.println("你們要好好學習"); } }有Daughter 類，繼承了父類Father類，并使用了父類中的屬性和方法，
public class Daughter extends Father{ //子類自身的方法 public static void run(){ System.out.println("我喜歡跑步"); } public static void main(String[] args) { //父親的身高178.0cm, 靜態屬性也可以通過類.屬性名訪問， System.out.println("父親的身高"+Father.tall+"cm"); Daughter daughter=new Daughter(); //你們要好好學習. 子類可以直接使用父類的方法 daughter.say(); //10000000 子類可以直接使用父類的有權限的屬性 System.out.println(daughter.money); //訪問父類的私有屬性，要用get，set方法 System.out.println("父親有"+daughter.getCar()+"輛車"); System.out.println("父親的名字"+daughter.name); //呼叫子類自己的方法 Daughter.run(); } }結果：
父親的身高178.0cm 你們要好好學習 10000000 父親有2輛車 父親的名字ThreePure
我喜歡跑步由上可知，繼承只是繼承了父類的非private屬性方法，當要使用私有屬性變數時，可以通過get/set方法進行訪問，
四、繼承中與構造器相關
1、子類不繼承父類的構造器（構造方法或者建構式），它只是呼叫，
2、如果父類構造器沒有引數，則在子類的構造器中不需要使用 super 關鍵字呼叫父類構造器，系統會自動呼叫父類的無參構造器，
案例：父類，構造方法沒有引數：
public class Father {
public int money=10_000_000;
private int car=2;
public static double tall=178;
protected String name="ThreePure";
public Father() {
System.out.println("父類的構造方法被呼叫了");
}
public Father(int a) {
System.out.println("父類的有參構造方法被呼叫了，傳入引數為"+a);
}
}
子類，構造方法沒有引數：
public class Son extends Father{
public Son() {
//此處默認super()
System.out.println("子類的構造方法被呼叫了");
}
public Son(int a) {
System.out.println("子類的有參構造方法被呼叫了，傳入引數為"+a);
}
}
在子類中無參的構造方法默認呼叫了super（）方法，不需要顯性呼叫，如果一定要寫，則必須寫在子類無參構造器方法體的第一行，
main方法，用于啟動程式：
public class Application {
public static void main(String[] args) {
System.out.println("-----------創建物件-----------");
Son erzi1=new Son();
/*System.out.println("-----------創建物件-----------");
Son erzi2=new Son(100);*/
}
}
結果：
-----------創建物件----------- 父類的構造方法被呼叫了 子類的構造方法被呼叫了
3、如果子類構造器有引數，在創建一個子類物件時傳入引數，那么系統也會自動呼叫父類的無參構造器，
main方法更改如下
public class Application {
public static void main(String[] args) {
/*System.out.println("-----------創建物件-----------");
Son erzi1=new Son();*/
System.out.println("-----------創建物件-----------");
Son erzi2=new Son(100);
}
}
結果：
-----------創建物件----------- 父類的構造方法被呼叫了 子類的有參構造方法被呼叫了，傳入引數為100
得出結論：創建子類物件時，系統會默認呼叫父類的無參構造器，需要顯式地使用super（），
4、如果父類的構造器帶有引數，則必須在子類的構造器中顯式地通過 super 關鍵字呼叫父類的構造器并配以適當的引數串列，
對子類的更改如下：
public class Son extends Father{
public Son() {
super(10);
System.out.println("子類的構造方法被呼叫了");
}
public Son(int a) {
super();
System.out.println("子類的有參構造方法被呼叫了，傳入引數為"+a);
}
}
main方法更改如下：
public class Application {
public static void main(String[] args) {
System.out.println("-----------創建物件-----------");
Son erzi1=new Son();
System.out.println("-----------創建物件-----------");
Son erzi2=new Son(100);
}
}
結果：
-----------創建物件----------- 父類的有參構造方法被呼叫了，傳入引數為10 子類的構造方法被呼叫了 -----------創建物件----------- 父類的構造方法被呼叫了 子類的有參構造方法被呼叫了，傳入引數為100
五、super和this關鍵字
super關鍵字：我們可以通過super關鍵字來實作對父類成員的訪問，用來參考當前物件的父類，
this關鍵字：指向自己的參考，
父類代碼
public class Father {
protected String name="ThreePure";
public void print(){
System.out.println("Father_print");
}
}
子類
public class Son extends Father{
private String name="HJB";
public Son() {
System.out.println(super.name);
System.out.println(this.name);
test1();
}
@Override
public void print(){
System.out.println("Son_print");
}
public void test1(){
//呼叫上面的print（）方法，輸出Son
print();
//Son
this.print();
//Father，呼叫父類的print方法
super.print();
}
}
main方法
public class Application {
public static void main(String[] args) {
System.out.println("-----------創建物件-----------");
Son erzi1=new Son();
}
}
結果：
-----------創建物件----------- ThreePure //父類name屬性 HJB Son_print Son_print Father_print //父類方法
六、object類
java中，所有類都直接或者間接繼承于Object類，
在IDEA中，使用快捷鍵Ctrl+H，能打開Hierarchy 面板，從中我們就可以知道當前類繼承于哪個類以及被哪個類繼承，比如我的當前Father類，繼承于Object類，被Son，Daughter兩個類繼承，
七、重寫
在子類中創建了一個與父類中名稱相同、回傳值型別相同、引數串列的方法相同，只是方法體中的實作不同，以實作不同于父類的功能，這種方式被稱為方法重寫（override），又稱為方法覆寫、方法復寫，
關于重寫，詳情參見【Java的重寫】
八、注意事項
1、final 關鍵字宣告類可以把類定義為不能繼承的，即最終類；
public final class Father {}
public class Son extends Father{}
//報錯：Cannot inherit from final 'characteristic.Father'
2、 implements 關鍵字是表示繼承介面，介面是允許多繼承的，
public interface A {
public void run();
}
public interface B {
public void show();
}
public class C implements A,B {
}
3、強烈建議在重寫方法前加上 @Override 注解
父類：
public class Override1 { private void method() { System.out.println("Override1.method()"); } }
//子類
public class Override2 extends Override1{
private void method() {
System.out.println("Override2.method()");
}
public void myMethod(){
method();
}
public static void main(String[] args) {
Override2 a = new Override2();
a.myMethod();
}
}
結果：編譯通過 Override2.method()
這里父類的method（）被設定成私有屬性，private 的方法是無法被子類重寫的，但是在子類中嘗試覆寫method（）方法，并且能編譯通過和輸出結果，
這是因為子類的method（）并不是重寫方法，而僅僅是與父類method（）方法重名的方法，追其原因是因為缺少了@Override注解，java編譯器以為這是一個普通的方法，在Override2 類中使用快捷鍵Alt+Insert快捷鍵插入重寫方法，發現private 方法無法生成重寫方法，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/118167.html
標籤：Java