Java中的抽象類

抽象類

抽象是一種概念，而不是如何實現，好比你的老闆說，你們加油哈，未來發財了人人有份。又如，好好學，未來必成大牛，這些均可以理解成是一種抽象的，你也能夠理解成所謂的抽象就是光說不作。

在Java中經過abstract關鍵字定義抽象類，以下

abstract class Base{
    ....
}

被定義爲抽象的類，不能使用new關鍵字，首先咱們得理解一件事，那就是抽象類，不是給你直接拿來用的，否則就不叫抽象了。

不只類能夠是抽象的，方法也一樣能夠是抽象的，好比下面這段代碼

class Base{
    abstract void hello(){
        System.out.println("hello");
    }
}

不過上面這段代碼是錯誤的，咱們說抽象是光說不作的，而上面這個hello方法，把具體代碼給實現了，因此是通不過編譯器的，另一點若是定義了抽象方法，類也必須是抽象的。下面這段代碼纔是正確的

abstract class Base{
    abstract void hello();
}

方法能夠把大括號去掉，而且後面得加上分號。下面是一個實例

abstract class Base{
    abstract void hello();
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        A a = new A();
        B b = new B();

        a.hello();
        b.hello();
    }
}

------Output------
hello A
hello B

由於是抽象類因此咱們必須在繼承它的子類中實現具體的方法。那麼問題來了，既然都得本身去實現，那和下面這段代碼有什麼區別嗎

class Base{
    
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        A a = new A();
        B b = new B();

        a.hello();
        b.hello();
    }
}

------Output------
hello A
hello B

這樣確定是沒有問題的，可是若是說咱們想運用多態，就不太行了，咱們將上面這段改成多態就會報錯，以下

class Base{
    
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        Base a = new A(); // 注意引用類型
        Base b = new B(); // 注意引用類型

        a.hello();
        b.hello();
    }
}

報錯了

咱們改爲多態之後就報錯了，由於在運用多態時，Base類只認Base中有的方法，除非是子類覆蓋Base中的方法。好比下面這段代碼是能夠的

class Base{
    public void hello(){
        System.out.println("hello Base");
    }
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        Base a = new A();
        Base b = new B();

        a.hello();
        b.hello();
    }
}

------Output------
hello A
hello B

雖然這樣能夠運行，可是你有沒有發現，咱們必須實現父類中的hello方法，而若是不實現就不行，像這個狀況下，使用抽象類就比較合適了，代碼以下

abstract class Base{
   abstract public void hello();
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        Base a = new A();
        Base b = new B();

        a.hello();
        b.hello();
    }
}

------Output------
hello A
hello B

另外使用抽象類還有一個好處，咱們一眼看過去就能知道，這是一個抽象類。而若是是下面這段代碼，就沒那麼容易分辨了

class Base{
    public void hello(){
        System.out.println("hello Base");
    }
}

class A extends Base{
    public void hello(){
        System.out.println("hello A");
    }
}

class B extends Base{
    public void hello(){
        System.out.println("hello B");
    }
}

class app{
    public static void main(String[] args){
        Base a = new A();
        Base b = new B();

        a.hello();
        b.hello();
    }
}

雖然在代碼少的狀況下，也能很好的分辨，可是若是代碼多了，就沒那麼容易分辨了。

抽象類在什麼狀況下比較適用

須要運用多態，而且某些方法在子類中必須重定義時。

參考

JAVA: 爲何要使用"抽象類"? 使用"抽象類"有什麼好處?