1.抽象abstract類的特點：

　　　　　　　　a.抽象類或抽象方法必須用abstract關鍵字修飾

　　　　　　　　b.抽象類中不一定有抽象方法，但是有抽象方法的類一定是抽象類

　　　　　　　　c.抽象類不能被例項化，因為它不是具體的，抽象類有構造方法，但是不能例項化，抽象類的構造方法是提供給抽象類的子類訪問父類資料初始化

2.抽象類的子類：

　　　　　　　　a.若子類是抽象類，與上一致

　　　　　　　　b.若子類不是抽象類，是具體類，就要(強制)重寫父類中的抽象方法，即抽象類的例項化是依靠具體的子類來實現的

3.抽象類的成員特點：

　　　　　　　　a.成員變數：可以是變數，也可以是常量

　　　　　　　　b.構造方法：有，帶不帶參的構造方法都可以有

　　　　　　　　c.成員方法：既可以是抽象方法，也可以是非抽象的

　　　　　　　　　　　　　　　　抽象類的成員方法如果是抽象方法，則不允許該抽象方法有方法體，表示需要子類來繼承，強制子類來做的事

　　　　　　　　　　　　　　　　抽象類的成員方法如果是非抽象方法，則表示子類繼承的事情，提高程式碼的複用性

4.關於abstract的幾個非法修飾符：

　　　　　　　　final/private+abstract:很明顯abstract類是需要被繼承來實現功能的，private修飾子類繼承不到，final修飾無法被繼承

　　　　　　　　static+abstract：無意義，用abstract修飾的方法沒有方法體，用static修飾的靜態方法可以通過類名.的方式直接呼叫，而呼叫一個沒有方法體的方法沒有意義

5.程式碼演示：

abstract class Animal{
    public int num=10;
    public final double PI=3.14;
    public Animal(){
        System.out.println("抽象父類的構造方法");
    }
    public Animal(int num){this.num=num;}
    public abstract void show();
    public int getNum(){
        return num;
    }
    public void setNum(int
 
 num){
        this.num=num;
    }
    public void method(){
        System.out.println("我是抽象類中的普通方法，可以有方法體");
    }

}
class Dog extends Animal{
    int num=20;
    public Dog(){
        System.out.println("dog子類的構造方法");
    }
    public void show(){
        System.out.println("我是普通類，繼承了抽象類，所以一定要重寫抽象父類的抽象方法，因為抽象父類中的抽象方法表示要強制子類做的事");
    }
    public void bark(){
        System.out.println("我是動物，也是狗，我可以看門，會吠");
    }
    public void method(){
        System.out.println("可以重寫抽象父類中的方法");
    }
}
abstract class Cat extends Animal{
    public void show(){
        System.out.println("我們一起喵喵喵");
    }
}
class   AbstractDemo {
    public static void main(String[] args) {
        //Animal a=new Cat();報錯，因為Cat類也是抽象類，也是不允許這樣例項化的
        Animal a=new Dog();
        a.method();
        a.show();
        //a.bark();多型的弊端，可以通過向下轉型
        Dog d= (Dog) a;
        d.bark();
        //Cat c= (Cat) a;
        //c.method();
        //c.show();
    }
}