1.java繼承

1.1概念

• 繼承就是子類繼承父類的特徵和行為，使得子類物件（例項）具有父類的例項域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
• 繼承可以使用extends和implements這兩個關鍵字來實現繼承，而且所有的類都是繼承於java.lang.Object,當一個類沒有繼承的兩個關鍵字, 則預設繼承object (這個類在java.lang包中，所以不需要import)祖先類。

1.2繼承的特性

• 子類擁有父類非private的屬性、方法。
• 子類可以擁有自己的屬性和方法。即子類可以對父類進行擴充套件。
• 子類可以用自己的方式實現父類的方法。
• Java 的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一 個父類，多重繼承就是，例如A類繼承B類，B類繼承C類,所以按照關係就是C類是B類的父類，B類是A類的父類，這是Java繼承區別於C++繼承的一個特性。
• 提高了類之間的耦合性(繼承的缺點，耦合度高就會造成程式碼之間的聯絡越緊密,程式碼獨立性越差)

1.3格式

1 class 父類{
2 }
3 class 子類 extends 父類{
4 }

1.4例項

1.4.1extends關鍵字

在Java中,類的繼承是單一繼承, 也就是說，一個子類只能擁有一個父類, 所以extends只能繼承一個類。

 1 public class Animal {
 2     private String name ;
 3     private int id:
 4     public Animal() {}
 5     public Animal (String myName，int myid) {
 6         //初始化屬性值.
 7     }
 8     public void eat() { //吃東西方法的具體實現 }
 9     public void sleep() { //睡覺方法的具體實觀}
10 }
11 
12 public class Penguin extends Animal {
13 }
14         
 

1.4.2implements關鍵字

使用implements關鍵字可以變相的使java具有多繼承的特性，使用範圍為類繼承介面的情況，可以同時繼承多個介面(介面跟介面之間採用逗號分隔，下面例子中的A與B)。

 1 public interface A {
 2     public void eat() ;
 3     public void sleep() ;
 4 }
 5 public interface B {
 6     public void show() ;
 7 }
 8 public class C implements A, B{
 9     public void eat() {}
10     public void sleep() {}
11     public void show() {}
12 }
 

1.4.3super與this關鍵字

super關鍵字 : 我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前物件的父類。
this關鍵字 : 指向自己的引用。

 1 class Animal {
 2     void eat() {
 3         System.out.println(" animal : eat");
 4     }
 5 }
 6 class Dog extends Animal {
 7     void eat() {
 8         System.out.println(" dog : eat");
 9 }
10     void eatTest() {
11         this.eat();    // this 呼叫自己的方法.
12         super.eat();  // super 呼叫父類方法
13     }
14 }
15 Animal a = new Animal();
16 a.eat();
17 Dogd = new Dog();
18 d.eatTest();
19         

1.4.4構造器

• 子類是不繼承父類的構造器(構造方法或者建構函式)的，它只是呼叫(隱式或顯式)。如果父類的構造器帶有引數，則必須在F類的構造器中顯式地通過super 關鍵字呼叫父類的構造器並配以適當的引數列表。
• 如果父類構造器沒有引數，則在子類的構造器中不需要使用super 關鍵字呼叫父類構造器，系統會自動呼叫父類的無參構造器。

 1 class SuperC1ass {
 2   private int n;
 3   SuperClass() {
 4     System.out.println("SuperClass()");
 5   }
 6   SuperClass(int n) {
 7     System.out.println("SuperClass(int n)");
 8     this.n = n;
 9   }
10 }
11 // SubClass1類繼承
12 class SubClass1 extends SuperClass {
13   private int n;
14   SubClass1(){     //自動呼叫父類的無引數構造器
15     System.out.println("SubClass1");
16   }
17   public SubClass1(int n) {
18     super(300);    //{ 呼叫父類中帶有引數的構造器
19     System.out.println(”SubClass1(int n):" +n);
20     this.n = n;
21   }
22 }
23 // SubClass2類繼承
24 class SubClass2 extends SuperClass {
25   private int n;
26   SubClass2() {
27     super(300);    //{ 呼叫父類中帶有引數的構造器
28     System.out.println("SubClass2");
29   }
30   public SubClass2(int n){ //自動呼叫父類的無引數構造器
31     System.out.println("SubClass2(int n):" +n);
32     this.n= n
33   }
34 }
35 System.out.println("-----SubClass類繼承-----");
36 SubClass1 sc1 = new SubClass1();
37 SubClass1 sc2 = new SubClass1(100);
38 System.out.println("-----SubC1ass2類繼------");
39 SubClass2 sc3 = new SubClass2();
40 SubClass2 sc4 = new SubClass (200);

2.重寫(Override)與過載(Overload)

2.1重寫規則

• 引數列表必須完全與被重寫方法的相同。
• 返回型別與被重寫方法的返回型別可以不相同，但是必須是父類返回值的派生類(java5及更早版本返回型別要-樣, java7 及更高版本可以不同)。
• 訪問許可權不能比父類中被重寫的方法的訪問許可權更低。例如:如果父類的一個方法被宣告為public, 那麼在子類中重寫該方法就不能宣告為protected.
• 父類的成員方法只能被它的子類重寫。
• 宣告為final的方法不能被重寫。
• 宣告為static的方法不能被重寫，但是能夠被再次宣告。
• 子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為private和final的方法。
• 子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為public和protected的非final方法。
• 寫的方法能夠丟擲任何非強制異常，無論被重寫的方法是否丟擲異常。但是.重寫的方法不能丟擲新的強制性異常，或者比被重寫方法宣告的更廣泛的強制性異常,反之則可以。
• 構造方法不能被重寫。
• 如果不能繼承一個方法，則不能重寫這個方法。

2.2過載規則

• 被過載的方法必須改變引數列表(引數個數或型別不一樣);
• 被過載的方法可以改變返回型別:
• 被過載的方法可以改變訪問修飾符;
• 被過載的方法可以宣告新的或更廣的檢查異常;
• 方法能夠在同一個類中或者在一個 子類中被過載。
• 無法以返回值型別作為過載函式的區分標準。

2.3重寫與過載的區別

2.4.1重寫

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫，返回值和形參都不能改
變。即外殼不變,核心重寫!
重寫的好處在於子類可以根據需要，定義特定於自己的行為。也就是說子類能夠根據
需要實現父類的方法。

 1 class Animal {
 2     public void move() {
 3         System.out.println("動物可以移動")；
 4     }
 5 }
 6 
 7 class Dog extends Animal {
 8     public void move() {
 9         System. out. print1n("狗可以跑和走");
10     }
11 }
12 Animal a = new Animal();     // Animal物件
13 a.move();    //執行Animal類的方法
14 
15 Animal b = new Dog();     //Dog物件
16 b.move();    //執行Dog類的方法
17         

2.4.2過載

過載(overloading)是在一個類裡面， 方法名字相同，而引數不同。返回型別可以相同
也可以不同。
每個過載的方法(或者建構函式)都必須有一個獨一 無的引數型別列表。
最常用的地方就是構造器的過載。

 1 public class Overloading {
 2     public int test() {
 3         System.out.println("test1")；
 4         return 1；
 5     }
 6     public void test(int a) {
 7         System.out.println("test2")；
 8     }
 9     //以下兩個引數型別順序不同
10     public String test(int a, String s) {
11         System.out.println("test3");
12         return "returntest3";
13     }
14     public String test (String s, int a) {
15         System.out.println(" test4");
16         return "returntest4"；
17     }
18 }
19 Overloading o = new overloading();
20 System.out.println(o.test()) ;
21 o.test(1);
22 System.out.println(o.test(1,"test3"));
23 System.out.println(o.test("test4",1));
24                         

本文來自部落格園，作者：Aurora*，轉載請註明原文連結：https://www.cnblogs.com/lang12/p/15366408.html