2018-08-30学习记录

abstract关键字： 

1）用abstract关键字修饰一个类时，这个类叫做抽象类；用abstract关键字修饰一个方法时，这个方法叫关键方法； 

2）含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写； 

3）抽象类不能被实例化； 

4）抽象方法只需声明，不需实现。

classAnimal{ private String name;

    Animal(String name) {

        this.name = name;

    }

    public void enjoy() {

        System.out.println("叫声...");

    }

}classCatextendsAnimal{    private String eyeColor;

    Cat(String name,String eyeColor) {

        super(name);

        this.eyeColor = eyeColor;

    }

    public void enjoy() {

        System.out.println("猫叫声...");

    }

}classDogextendsAnimal{    private String furColor;

    Dog(String name,String furColor) {

        super(name);

        this.furColor = furColor;

    }

    public void enjoy() {

        System.out.println("狗叫声...");

    }

}classLady{    private String name;

    private Animal pet;

    public Lady(String name,Animal pet) {

        this.name = name;

        this.pet = pet;

    }

    public void myPetEnjoy() {

        pet.enjoy();

    }

}public classTest{    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 classAnimal{

此时，Animal所有的子类都必须重写这个enjoy方法，如果不重写，则编译会出错。 

如果我声明一个类为抽象类，比如：

abstractclassCat{}

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

Cat c  = new Cat();

因为Cat是一个抽象类。