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

虽然在代码少的情况下，也能很好的分辨，但是如果代码多了，就没那么容易分辨了。