抽象類和介面

一、抽象類

1.定義

在面向物件的概念中，所有的物件都是通過類來描繪的，但是反過來，並不是所有的類都是用來描繪物件的，如果一個類中沒有包含足夠的資訊來描繪一個具體的物件，這樣的類就是抽象類。

2.性質

（1）抽象類不能例項化物件。

（2）抽象類的成員變數、成員方法和構造方法的訪問方式和普通類一樣。

（3）抽象類必須被繼承，才能被使用。

（4）一個繼承抽象類的類必須實現抽象父類的所有抽象方法，否則這個類仍然是抽象類。

（5）在Java中抽象類表示的是一種繼承關係，一個類只能繼承一個抽象類，而一個類卻可以實現多個介面。

3.定義抽象類

使用abstract class來定義抽象類。

例如下列程式碼定義了抽象類Employee

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 個構造方法。

但是 不能使用Employee類直接新建例項！

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();
    }
}
 

4.繼承抽象類

我們能通過一般的方法繼承Employee類：

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 個成員方法，且通過該方法可以設定或獲取三個成員變數。

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();
    }
}

5.抽象方法

如果你想設計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現由它的子類確定，那麼你可以在父類中宣告該方法為抽象方法。

Abstract 關鍵字同樣可以用來宣告抽象方法，抽象方法只包含一個方法名，而沒有方法體。

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

例如：

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

宣告抽象方法會造成以下兩個結果：

• 如果一個類包含抽象方法，那麼該類必須是抽象類。
• 任何子類必須重寫父類的抽象方法，或者宣告自身為抽象類。

也就是上文提到的抽象類的性質中的第4條。

6.抽象類總結規定

• 抽象類不能被例項化(初學者很容易犯的錯)，如果被例項化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以建立物件。
• 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。
• 抽象類中的抽象方法只是宣告，不包含方法體，就是不給出方法的具體實現也就是方法的具體功能。
• 構造方法，類方法（用 static 修飾的方法）不能宣告為抽象方法。
• 抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。

二、介面

1.定義

在JAVA程式語言中是一個抽象型別，是抽象方法的集合，介面通常以interface來宣告。一個類通過繼承介面的方式，從而來繼承介面的抽象方法。

2.性質

（1）介面不能用於例項化物件。

（2）介面沒有構造方法。

（3）介面中所有的方法必須是抽象方法。

（4）介面不能包含成員變數，除了 static 和 final 變數。

（5）介面不是被類繼承了，而是要被類實現。 （implements）

（6）介面支援多繼承。

（7）介面中每一個方法也是隱式抽象的,介面中的方法會被隱式的指定為 public abstract（只能是 public abstract，其他修飾符都會報錯）。

（8）介面中可以含有變數，但是介面中的變數會被隱式的指定為 public static final 變數（並且只能是 public，用 private 修飾會報編譯錯誤）。

（9）介面中的方法是不能在介面中實現的，只能由實現介面的類來實現介面中的方法。

3.宣告介面

介面的宣告語法格式如下：

[可見度] interface 介面名稱 [extends 其他的介面名] {
        // 宣告變數
        // 抽象方法
}


//Interface關鍵字用來宣告一個介面。下面是介面宣告的一個簡單例子。
public interface NameOfInterface
{
   //任何型別 final, static 欄位
   //抽象方法
}

注意：介面中的方法都是公有的。

//例項：
interface Animal {
   public void eat();
   public void travel();
}

4.實現介面

當類實現介面的時候，類要實現介面中所有的方法。否則，類必須宣告為抽象的類。（與抽象類類似）

類使用implements關鍵字實現介面。在類宣告中，Implements關鍵字放在class聲明後面。

//實現一個介面的語法，可以使用這個公式：
...implements 介面名稱[, 其他介面名稱, 其他介面名稱..., ...] ...

例項：

public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}`

重寫介面中宣告的方法時，需要注意以下規則：

• 類在實現介面的方法時，不能丟擲強制性異常，只能在介面中，或者繼承介面的抽象類中丟擲該強制性異常。
• 類在重寫方法時要保持一致的方法名，並且應該保持相同或者相相容的返回值型別。
• 如果實現介面的類是抽象類，那麼就沒必要實現該介面的方法。

在實現介面的時候，也要注意一些規則：

• 一個類可以同時實現多個介面。
• 一個類只能繼承一個類，但是能實現多個介面。
• 一個介面能繼承另一個介面，這和類之間的繼承比較相似。

5.介面的繼承

一個介面能繼承另一個介面，和類之間的繼承方式比較相似。介面的繼承使用extends關鍵字，子介面繼承父介面的方法。

下面的Sports介面被Hockey和Football介面繼承：

// 檔名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 檔名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 檔名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Hockey介面自己聲明瞭四個方法，從Sports介面繼承了兩個方法，這樣，實現Hockey介面的類需要實現六個方法。

相似的，實現Football介面的類需要實現五個方法，其中兩個來自於Sports介面。

6.介面的多繼承

在Java中，類的多繼承是不合法，但介面允許多繼承。

在介面的多繼承中extends關鍵字只需要使用一次，在其後跟著繼承介面。 如下所示：

public interface Hockey extends Sports, Event

以上的程式片段是合法定義的子介面，與類不同的是，介面允許多繼承，而 Sports及 Event 可能定義或是繼承相同的方法