java抽象類終極心得

Java 抽象類

---

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

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

由於抽象類不能實例化對象，所以抽象類必須被繼承，才能被使用。

父類包含了子類集合的常見的方法，但是由於父類本身是抽象的，所以不能使用這些方法。

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

 

 

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

public static 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類的對象，更不能引用它的變量和方法

但是可以通過創建一個類來繼承這個抽象類

 

public static class Salary extends Employee//用Salary類繼承，一定要用static，因爲最終要在main方法中實例化，main方法是靜態的，而且還要保持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;
    }
}

main方法

public static void main(String[] args) throws IOException {
    Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);//因爲Salary的構造函數是含參的，所以在實例化時要傳入對應的值
    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();

}

 

 

抽象方法

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

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

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

public abstract class Employee
{
    private String name;
    private String address;
    private int number;

    public abstract double computePay();

    //其餘代碼
}

聲明抽象方法會造成以下兩個結果：

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

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

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

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

    //其餘代碼
}

---

抽象類總結規定

• 1. 抽象類不能被實例化(初學者很容易犯的錯)，如果被實例化，就會報錯，編譯無法通過。只有抽象類的非抽象子類（繼承了這個抽象類的類）可以創建對象。

• 2. 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。

• 3. 抽象類中的抽象方法只是聲明，不包含方法體（就是不給出方法的具體實現）。

• 4. 構造方法，類方法（用 static 修飾的方法）不能聲明爲抽象方法（就是方法不是靜態方法）。

• 5. 抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。即要是繼承了抽象類，必須在子類中重寫抽象類的抽象方法