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是一個抽象類。