抽象類

5.5.1 抽象方法和抽象類

抽象方法和抽象類的規則：

• 抽象方法和抽象類必須使用abstract修飾符來定義，有抽象方法的類只能被定義成抽象類，抽象類裏可以沒有抽象方法，抽象方法不能有方法體。

• 抽象類不能被實例化，無法使用new關鍵字來調用抽象類的構造器創建抽象類的實例。

• 抽象類可以包含成員變量，方法，構造器，初始化類，內部類。抽象類不能用於創建實例，主要是用於被其子類調用

• 含有抽象方法的類只能被定義成抽象類

抽象方法和空方法體不是同一個概念。public abstract void test();是一個抽象方法。public void test(){}是一個空方法體。

Shape.java

package code.shape;
public abstract class Shape{
    {
        System.out.println("執行Shape的初始化塊...");
    }
    private String color;
    public abstract double calPerimeter();
    public abstract String getType();
    public Shape(){
    }
    public Shape(String color){
        System.out.println("執行Shape的構造器...");
        this.color = color;
    }
    public void setColor(String color){
        this.color = color;
    }
    public String getColor(){
        return color;
    }
}

Triangle.java

package code.shape;
import code.shape.*;
public class Triangle extends Shape{
    private double a;
    private double b;
    private double c;
    public Triangle(String color,double a,double b,double c){
        super(color);
        this.setSides(a,b,c);
    }
    public void setSides(double a,double b,double c){
        if(a>=b+c||b>=a+c||c>a+b){
            System.out.println("三角形兩邊之和必須大於等於第三邊");
            return;
        }
        this.a = a;
        this.b = b;
        this.c = c;

    }
    public double calPerimeter(){
        return a+b+c;
    }
    public String getType(){
        return "三角形";
    }

}

Circle.java

package code.shape;
import java.lang.Math;
import code.shape.*;
public class Circle extends Shape{
    private double radius;
    public Circle(String color,double radius){
        super(color);
        this.radius = radius;
    }
    public void setRadius(double radius){
        this.radius = radius;
    }
    public double calPerimeter(){
        return 2*Math.PI*radius;
    }
    public String getType(){
        return getColor() + "圓形";
    }
    public static void main(String []args){
        Shape s1 = new Triangle("黑色",3,4,5);
        Shape s2 = new Circle("紅色",4);
        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());
        System.out.println(s2.getType());
        System.out.println(s2.calPerimeter());
    }
}

執行Shape的初始化塊…
執行Shape的構造器…
執行Shape的初始化塊…
執行Shape的構造器…
三角形
12.0
紅色圓形
25.132741228718345

當使用abstract修飾類時，表明這個類只能被繼承；當使用abstract修飾方法時，表明這個方法必須由子類提供實現（即重寫）。而final修飾的類不能被繼承，final修飾的方法不能被重寫。因此final和abstract永遠不能同時使用。

static和abstract並不是絕對互斥，static和abstract不能同時修飾某個方法，但可以同時修飾內部類。
abstract方法不能定義爲private訪問權限。abstract和private不能同時修飾方法。

5.5.2 抽象類的作用

從語義的角度來看，抽象類是從多個具體類中抽象出來的父類，它具有更高層次的抽象。
抽象類體現的就是一種模板模式的設計。
在上述Shape,Circle和Triangle三個類使用了模板模式，父類的普通方法依賴於一個抽象方法，而抽象方法則推遲到子類中實現。

SpeedMeter.java

package code.speed;
public abstract class SpeedMeter{
    private double turnRate;
    public SpeedMeter(){}
    public void setTurnRate(double turnRate){
        this.turnRate = turnRate;
    }
    public abstract double getRadius();
    public double getSpeed(){
        return java.lang.Math.PI * 2 *getRadius() * turnRate;
    }
}

carSpeedMeter.java

package code.speed;
public class carSpeedMeter extends SpeedMeter{
    public double getRadius(){
        return 0.28;
    }
    public static void main(String[] args){
        SpeedMeter sm = new carSpeedMeter();
        sm.setTurnRate(15);
        System.out.println(sm.getSpeed());
    }
}

26.389378290154266

規則：

• 抽象父類可以只定義需要使用的某些方法，把不能實現的部分方法抽象成抽象方法，留給其子類去實現。
• 父類中可能包含需要調用其他系列方法的方法，這些被調方法既可以由父類實現，也可以由其子類實現。父類裏提供的方法只是定義了一個通用算法，其實現也許並不完全由自身實現，而必須依賴於其子類的輔助。