1.引入概念：

狼和狗，兩個類，抽取他們所屬的共性：犬科。
犬科都有吼叫行為，具體是汪汪汪還是嗷嗷嗷，是不確定的，需要子類明確。
這些犬科不具體的功能，需要在類中標識出來，通過java中的關鍵字abstract（抽象）
定義了抽象函式的類也要被abstract修飾，即抽象類。
用法和繼承類似。
舉例：

abstract class 犬科(){
    abstract void 叫()；
    //用abstract修飾抽象函式
}

class Dog extends 犬科{
    void 叫(){
        System.out.println("汪汪汪")；
    }   
}

class
 
 Wolf extends 犬科{
    void 叫(){
        System.out.println("嗷嗷嗷")；
    }
}

2.抽象類的特點

1）抽象類和抽象方法都需要被abstract修飾。抽象方法一定定義在抽象類中。
2）抽象類不可以建立例項，因為呼叫抽象方法是沒有意義的。
3）只有覆蓋了抽象類的所有抽象方法後子類才可以例項化，否則這個子類還是一個抽象類。

3.抽象類的常見問題

1）抽象類一定是父類嗎？
答：
是的，因為抽象類是不斷抽取而來的

2）抽象類有建構函式嗎？
答：
有的，雖然能不能給自己的物件初始化，但是可以給自己的子類初始化。

3）抽象類和一般類有什麼不同？
答：
抽象類和一般類都是用來描述事物的，並且都可以定義屬性和功能，但是：
一般類可以描述具體的描述事物，可以建立物件；
抽象類描述事物的資訊不具體，不能建立物件，能夠定義抽象函式。

4）抽象類裡一定要定義抽象方法嗎？
答：
不一定，抽象類的另一個作用就是可以利用抽象類的特性使該類不能建立物件

5）abstract不能哪些關鍵字一起用？
答：
1 final ：最終不能更改，抽象肯定得定義抽象方法
2 private ：明顯….你都私有了不讓別人用還抽象幹嘛
3 static : 靜態直接能被類名呼叫，對抽象類來說是沒有意義的

4.抽象類簡單應用

需求：

公司中程式設計師有姓名，工號，薪水，工作內容
專案經理有姓名，工號，薪水，工作內容，獎金 進行建模。

解決步驟：
1）尋找涉及的物件

程式設計師：
    屬性：姓名，工號，薪水
    行為:工作內容 
專案經理：
    屬性：姓名，工號，薪水，獎金
    行為：工作內容

兩個物件具有共性，沒有子父類關係。將他們的共性抽取，共同型別：worker

員工:
    屬性：姓名，工號，薪水
    行為:工作內容 

員工的工作內容是不具體的，所以是抽象的，應該由子類實現
可以寫出員工類：

abstract class Worker{
    private String name;
    private String id;
    private double pay;

    // 建構函式，員工的3個屬性
    public worker(String name,String id,double pay){
        this.name = name;
        this.id = id;
        this.pay = pay;
    }

    // 抽象行為：工作
    public abstract void work();
}

寫出子類：程式設計師

class Programmer extends Worker{
    // 建構函式
    public programmer(String name,String id,double pay){
        // 引用父類
        super(name,id,pay);
    }

    // 工作行為：程式碼
    public void work(){
        System.out.println("I'm coding");
    }
}

寫出子類：經理

class Manager extends Worker{
    // 特有屬性：獎金
    private double bonus;
    // 建構函式，經理屬性
    public Manager(String name,String id,double pay,double bonus){
        super(name,id,pay);
        this.bonus = bonus;
    }
    // 工作行為：管理
    public void work(){
        System.out.println("I'm manageing");
    }
}

5.補充

對於上面3.4問題，舉例說明

有一個介面

interface Inter{
    public void show1();
    public void show2();
    public void show3();
}   

現在需要分別單獨使用show1和show2

//使用1方法
class InterDemo1 implements Inter{
    public void show1(){
        xxxx;
    }
    // 如果不覆蓋其他方法，這就是一個抽象類
    // 所以需要寫，即使用不到
    public void show2(){}
    public void show3(){}
}

//同上，使用2
class InterDemo2 implements Inter{
    public void show2(){
        xxxx;
    }
    public void show1(){}
    public void show3(){}
}

這樣做的話很費勁，複用性差
所以可以設定一個類，把四個方法覆蓋，再讓子類繼承

class InterImpl implements Inter{
    public void show1();
    public void show2();
    public void show3();
}
// 繼承InterImpl中的方法，直接使用show1就行了，簡化了很多
class InterDemo1 extends InterImpl{
    public void show1(){
        xxxx;
    }
}
// 同上，使用show2
class InterDemo1 extends InterImpl{
    public void show2(){
        xxxx;
    }
}

可是這樣做又出現問題了，這個InterImpl類 建立物件是沒有意義的，所以令其抽象化。

// 抽象化
abstract class InterImpl implements Inter{
    public void show1();
    public void show2();
    public void show3();
}

這就是沒有抽象方法的抽象類。

思想很重要。之所以使用繼承，是為了在對共性型別操作時更為簡單。