Java之抽象类（abstract关键字）

abstract关键字：
1）用abstract关键字修饰一个类时，这个类叫做抽象类；用abstract关键字修饰一个方法时，这个方法叫关键方法；
2）含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；
3）抽象类不能被实例化；
4）抽象方法只需声明，不需实现。

我们来分别解释一下：

class Animal {
    private String name;
    Animal(String name) {
        this.name = name;
    }
    public void enjoy() {
        System.out.println("叫声...");
    }
}

class Cat extends Animal {
    private String eyeColor;
    Cat(String name,String eyeColor) {
        super(name);
        this.eyeColor = eyeColor;
    }

    public void enjoy() {
        System.out.println("猫叫声...");
    }
}

class Dog extends Animal {
    private String furColor;

    Dog(String name,String furColor) {
        super(name);
        this.furColor = furColor;
    }

    public void enjoy() {
        System.out.println("狗叫声...");
    }
}

class Lady {
    private String name;
    private Animal pet;

    public Lady(String name,Animal pet) {
        this.name = name;
        this.pet = pet;
    }

    public void myPetEnjoy() {
        pet.enjoy();
    }
}

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("Dogname","black");
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        l1.myPetEnjoy();
        l2.myPetEnjoy();
    }
}

解释一下这个程序：首先有一个Animal类，有一个enjoy方法，输出“叫声…”，Dog类和Cat类均从Animal类继承，并重写了enjoy方法。但是我们可以看到，这里的Animal类中的enjoy方法根本就不需要实现，但是还必须定义，因为如果不定义的话对于Dog类和Cat类就不能重写，也就不能实现多态。

在这种情况下，我们在这个方法的前面加上一个abstract关键字，将这个方法定义为一个抽象方法，即改为：

public abstract void enjoy();

由于这个方法是在Animal类里面定义的，所以Animal类也必须定义为一个抽象类，即将代码第一行改为：

abstract class Animal {

此时，Animal所有的子类都必须重写这个enjoy方法，如果不重写，则编译会出错。
如果我声明一个类为抽象类，比如：

abstract class Cat {}

那么这个Cat类不能被实例化，也就是说，下面这句话是错误的：

Cat c  = new Cat();

因为Cat是一个抽象类。