java-類（class）繼承，重寫，重構，抽象，接口等

時間 2020-05-31

標籤 java class 繼承重寫抽象接口欄目 Java 简体版

原文原文鏈接

類的繼承格式

在 Java 中經過 extends 關鍵字能夠申明一個類是從另一個類繼承而來的，通常形式以下：html

class 父類 {
}
 
class 子類 extends 父類 {
}

爲何須要繼承

接下來咱們經過實例來講明這個需求。java

開發動物類，其中動物分別爲企鵝以及老鼠，要求以下：ide

企鵝：屬性（姓名，id），方法（吃，睡，自我介紹）
老鼠：屬性（姓名，id），方法（吃，睡，自我介紹）

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("你們好！我是"         + id + "號" + name + "."); 
    } 
}

這個Animal類就能夠做爲一個父類，而後企鵝類和老鼠類繼承這個類以後，就具備父類當中的屬性和方法，子類就不會存在重複的代碼，維護性也提升，代碼也更加簡潔，提升代碼的複用性（複用性主要是能夠屢次使用，不用再屢次寫一樣的代碼）繼承以後的代碼：函數

企鵝類：
public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

老鼠類：
public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

繼承類型

須要注意的是 Java 不支持多繼承，但支持多重繼承。ui

繼承的特性

子類擁有父類非 private 的屬性、方法。this
子類能夠擁有本身的屬性和方法，即子類能夠對父類進行擴展。spa
子類能夠用本身的方式實現父類的方法。設計
Java 的繼承是單繼承，可是能夠多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如 A 類繼承 B 類，B 類繼承 C 類，因此按照關係就是 C 類是 B 類的父類，B 類是 A 類的父類，這是 Java 繼承區別於 C++ 繼承的一個特性。code
提升了類之間的耦合性（繼承的缺點，耦合度高就會形成代碼之間的聯繫越緊密，代碼獨立性越差）。htm

繼承關鍵字

繼承可使用 extends 和 implements 這兩個關鍵字來實現繼承，並且全部的類都是繼承於 java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，因此不須要 import）祖先類。

extends關鍵字

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

implements關鍵字

使用 implements 關鍵字能夠變相的使java具備多繼承的特性，使用範圍爲類繼承接口的狀況，能夠同時繼承多個接口（接口跟接口之間採用逗號分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 與 this 關鍵字

super關鍵字：咱們能夠經過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。

this關鍵字：指向本身的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 調用本身的方法
    super.eat();  // super 調用父類方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

結果：
animal : eat
dog : eat
animal : eat

final關鍵字

final 關鍵字聲明類能夠把類定義爲不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫：

聲明類：final class 類名 {//類體}

聲明方法：修飾符(public/private/default/protected) final 返回值類型方法名(){//方法體}

注:實例變量也能夠被定義爲 final，被定義爲 final 的變量不能被修改。被聲明爲 final 類的方法自動地聲明爲 final，可是實例變量並非 final

構造器

子類是不繼承父類的構造器（構造方法或者構造函數）的，它只是調用（隱式或顯式）。若是父類的構造器帶有參數，則必須在子類的構造器中顯式地經過 super 關鍵字調用父類的構造器並配以適當的參數列表。

若是父類構造器沒有參數，則在子類的構造器中不須要使用 super 關鍵字調用父類構造器，系統會自動調用父類的無參構造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 類繼承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自動調用父類的無參數構造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 調用父類中帶有參數的構造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClas2 類繼承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 調用父類中帶有參數的構造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自動調用父類的無參數構造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 類繼承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 類繼承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

結果：
------SubClass 類繼承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 類繼承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

重寫(Override)

重寫是子類對父類的容許訪問的方法的實現過程進行從新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

重寫的好處在於子類能夠根據須要，定義特定於本身的行爲。也就是說子類可以根據須要實現父類的方法。

重寫方法不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的異常。例如：父類的一個方法申明瞭一個檢查異常 IOException，可是在重寫這個方法的時候不能拋出 Exception 異常，由於 Exception 是 IOException 的父類，只能拋出 IOException 的子類異常。

在面向對象原則裏，重寫意味着能夠重寫任何現有方法。實例以下：

class Animal{
   public void move(){
      System.out.println("動物能夠移動");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗能夠跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 對象
      Animal b = new Dog(); // Dog 對象
 
      a.move();// 執行 Animal 類的方法
 
      b.move();//執行 Dog 類的方法
   }
}

在上面的例子中能夠看到，儘管b屬於Animal類型，可是它運行的是Dog類的move方法。

這是因爲在編譯階段，只是檢查參數的引用類型。

然而在運行時，Java虛擬機(JVM)指定對象的類型而且運行該對象的方法。

所以在上面的例子中，之因此能編譯成功，是由於Animal類中存在move方法，然而運行時，運行的是特定對象的方法。

思考如下例子：

class Animal{
   public void move(){
      System.out.println("動物能夠移動");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗能夠跑和走");
   }
   public void bark(){
      System.out.println("狗能夠吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 對象
      Animal b = new Dog(); // Dog 對象
 
      a.move();// 執行 Animal 類的方法
      b.move();//執行 Dog 類的方法
      b.bark();
   }
}

以上實例編譯運行結果以下：

TestDog.java:30: cannot find symbol symbol : method bark() location: class Animal b.bark(); ^

該程序將拋出一個編譯錯誤，由於b的引用類型Animal沒有bark方法。

方法的重寫規則

參數列表必須徹底與被重寫方法的相同；
返回類型必須徹底與被重寫方法的返回類型相同；
訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：若是父類的一個方法被聲明爲public，那麼在子類中重寫該方法就不能聲明爲protected。
父類的成員方法只能被它的子類重寫。
聲明爲final的方法不能被重寫。
聲明爲static的方法不能被重寫，可是可以被再次聲明。
子類和父類在同一個包中，那麼子類能夠重寫父類全部方法，除了聲明爲private和final的方法。
子類和父類不在同一個包中，那麼子類只可以重寫父類的聲明爲public和protected的非final方法。
重寫的方法可以拋出任何非強制異常，不管被重寫的方法是否拋出異常。可是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更普遍的強制性異常，反之則能夠。
構造方法不能被重寫。
若是不能繼承一個方法，則不能重寫這個方法。

Super關鍵字的使用

當須要在子類中調用父類的被重寫方法時，要使用super關鍵字。

class Animal{
   public void move(){
      System.out.println("動物能夠移動");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 應用super類的方法
      System.out.println("狗能夠跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 對象
      b.move(); //執行 Dog類的方法
 
   }
}

結果：
動物能夠移動
狗能夠跑和走

重載(Overload)

重載(overloading) 是在一個類裏面，方法名字相同，而參數不一樣。返回類型能夠相同也能夠不一樣。

每一個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

最經常使用的地方就是構造器的重載。

重載規則:

被重載的方法必須改變參數列表(參數個數或類型不同)；
被重載的方法能夠改變返回類型；
被重載的方法能夠改變訪問修飾符；
被重載的方法能夠聲明新的或更廣的檢查異常；
方法可以在同一個類中或者在一個子類中被重載。
沒法以返回值類型做爲重載函數的區分標準。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //如下兩個參數類型順序不一樣
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重寫與重載之間的區別

總結

方法的重寫(Overriding)和重載(Overloading)是java多態性的不一樣表現，重寫是父類與子類之間多態性的一種表現，重載能夠理解成多態的具體表現形式。

(1)方法重載是一個類中定義了多個方法名相同,而他們的參數的數量不一樣或數量相同而類型和次序不一樣,則稱爲方法的重載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,並且參數的個數與類型同樣,返回值也同樣的方法,就稱爲重寫(Overriding)。
(3)方法重載是一個類的多態性表現,而方法重寫是子類與父類的一種多態性表現。

Java 多態

多態是同一個行爲具備多個不一樣表現形式或形態的能力。

多態就是同一個接口，使用不一樣的實例而執行不一樣操做，如圖所示：

多態的優勢

1. 消除類型之間的耦合關係
2. 可替換性
3. 可擴充性
4. 接口性
5. 靈活性
6. 簡化性

多態存在的三個必要條件

繼承
重寫
父類引用指向子類對象

當使用多態方式調用方法時，首先檢查父類中是否有該方法，若是沒有，則編譯錯誤；若是有，再去調用子類的同名方法。

多態的好處：可使程序有良好的擴展，並能夠對全部類的對象進行通用處理。

如下是一個多態實例的演示，詳細說明請看註釋：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 對象調用 show 方法
      show(new Dog());  // 以 Dog 對象調用 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 調用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 調用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  // 貓作的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗作的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

結果：

吃魚 抓老鼠 吃骨頭 看家 吃魚 抓老鼠

虛函數

虛函數的存在是爲了多態。

Java 中其實沒有虛函數的概念，它的普通函數就至關於 C++ 的虛函數，動態綁定是Java的默認行爲。若是 Java 中不但願某個函數具備虛函數特性，能夠加上 final 關鍵字變成非虛函數。

重寫

咱們將介紹在 Java 中，當設計類時，被重寫的方法的行爲怎樣影響多態性。

咱們已經討論了方法的重寫，也就是子類可以重寫父類的方法。

當子類對象調用重寫的方法時，調用的是子類的方法，而不是父類中被重寫的方法。

要想調用父類中被重寫的方法，則必須使用關鍵字 super。

Employee.java 文件代碼：
/* 文件名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 構造函數");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("郵寄支票給： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

Salary.java 文件代碼：
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 整年工資
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 類的 mailCheck 方法 ");
       System.out.println("郵寄支票給：" + getName()
       + " ，工資爲：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("計算工資，付給：" + getName());
      return salary/52;
   }
}

VirtualDemo.java 文件代碼：
/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("員工 A", "北京", 3, 3600.00);
      Employee e = new Salary("員工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用調用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用調用 mailCheck--");
      e.mailCheck();
    }
}

以上實例編譯運行結果以下：

Employee 構造函數
Employee 構造函數
使用 Salary 的引用調用 mailCheck -- 
Salary 類的 mailCheck 方法 
郵寄支票給：員工 A ，工資爲：3600.0

使用 Employee 的引用調用 mailCheck--
Salary 類的 mailCheck 方法 
郵寄支票給：員工 B ，工資爲：2400.0

例子解析

實例中，實例化了兩個 Salary 對象：一個使用 Salary 引用 s，另外一個使用 Employee 引用 e。
當調用 s.mailCheck() 時，編譯器在編譯時會在 Salary 類中找到 mailCheck()，執行過程 JVM 就調用 Salary 類的 mailCheck()。
由於 e 是 Employee 的引用，因此調用 e 的 mailCheck() 方法時，編譯器會去 Employee 類查找 mailCheck() 方法。
在編譯的時候，編譯器使用 Employee 類中的 mailCheck() 方法驗證該語句，可是在運行的時候，Java虛擬機(JVM)調用的是 Salary 類中的 mailCheck() 方法。

以上整個過程被稱爲虛擬方法調用，該方法被稱爲虛擬方法。

Java中全部的方法都能以這種方式表現，所以，重寫的方法能在運行時調用，無論編譯的時候源代碼中引用變量是什麼數據類型。

多態的實現方式

方式一：重寫：

這個內容已經在上一章節詳細講過，就再也不闡述，詳細可訪問：Java 重寫(Override)與重載(Overload)。

方式二：接口

1. 生活中的接口最具表明性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，由於這個是每一個國家都有各自規定的接口規則，有可能到國外就不行，那是由於國外本身定義的接口類型。
2. java中的接口相似於生活中的接口，就是一些方法特徵的集合，但沒有方法的實現。具體能夠看 java接口這一章節的內容。

方式三：抽象類和抽象方法

Java 抽象類

在面向對象的概念中，全部的對象都是經過類來描繪的，可是反過來，並非全部的類都是用來描繪對象的，若是一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。

抽象類除了不能實例化對象以外，類的其它功能依然存在，成員變量、成員方法和構造方法的訪問方式和普通類同樣。

因爲抽象類不能實例化對象，因此抽象類必須被繼承，才能被使用。也是由於這個緣由，一般在設計階段決定要不要設計抽象類。

父類包含了子類集合的常見的方法，可是因爲父類自己是抽象的，因此不能使用這些方法。

在Java中抽象類表示的是一種繼承關係，一個類只能繼承一個抽象類，而一個類卻能夠實現多個接口。

抽象類

在Java語言中使用abstract class來定義抽象類。以下實例：

/* 文件名 : Employee.java */
public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
   {
      return name + " " + address + " " + number;
   }
   public String getName()
   {
      return name;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
   public int getNumber()
   {
     return number;
   }
}

注意到該 Employee 類沒有什麼不一樣，儘管該類是抽象類，可是它仍然有 3 個成員變量，7 個成員方法和 1 個構造方法。如今若是你嘗試以下的例子：

AbstractDemo.java 文件代碼：
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      /* 如下是不容許的，會引起錯誤 */
      Employee e = new Employee("George W.", "Houston, TX", 43);
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}
當你嘗試編譯AbstractDemo類時，會產生以下錯誤：

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

抽象類繼承：

Salary.java 文件代碼：
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double
      salary)
   {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName()
       + " with salary " + salary);
   }
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}
儘管咱們不能實例化一個 Employee 類的對象，可是若是咱們實例化一個 Salary 類對象，該對象將從 Employee 類繼承 7 個成員方法，且經過該方法能夠設置或獲取三個成員變量。

AbstractDemo.java 文件代碼：
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
 
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}
以上程序編譯運行結果以下：

Constructing an Employee
Constructing an Employee
Call mailCheck using  Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.

抽象方法

若是你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類肯定，那麼你能夠在父類中聲明該方法爲抽象方法。

Abstract 關鍵字一樣能夠用來聲明抽象方法，抽象方法只包含一個方法名，而沒有方法體。

抽象方法沒有定義，方法名後面直接跟一個分號，而不是花括號。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其他代碼
}

聲明抽象方法會形成如下兩個結果：

若是一個類包含抽象方法，那麼該類必須是抽象類。
任何子類必須重寫父類的抽象方法，或者聲明自身爲抽象類。

繼承抽象方法的子類必須重寫該方法。不然，該子類也必須聲明爲抽象類。最終，必須有子類實現該抽象方法，不然，從最初的父類到最終的子類都不能用來實例化對象。

若是Salary類繼承了Employee類，那麼它必須實現computePay()方法：

Salary.java 文件代碼：
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其他代碼
}