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: 为何要使用"抽象类"? 使用"抽象类"有什么好处?