当多个类中出现相同功能，但是功能的主体不同，这时可以向上抽取。

只抽取功能定义，而不抽取功能主体

如果一个类中有不确定的部分，也就是该事物的功能需要明确出现，但是无法定义主体，通过抽象方法来表示

抽象：abstract

抽象类的特点：

1、抽象方法一定在抽象类中，既如何类中的一个方法用abstract修饰后成为抽象方法，那么这个类的前面一定也要加上abstract修饰

2、抽象方法和抽象类都必须被abstract关键字修饰

3、抽象类不可以用new创建新对象，因为调用抽象的方法没有意义

4、抽象类中的方法要被使用，必须由子类重新复写所有的抽象方法后，建立子类调用

　　如果子类只复写了部分抽象方法，那么子类还只是个抽象类

5、抽象类中可以不定义抽象方法，这样做仅仅是为了不让该类建立对象。

class  abstractDemo
 {
     public static void main(String[] args) 
     {
         Person p = new Person();
         p.study();
     }
 }
 abstract class Person
 {
     abstract void study();//抽象类的写法，没有{}的方法体，以；为语句结束的标志
     //abstract void study1();如果写了这一句，程序无法执行，因为study1在子类中没有被覆盖，会使子类也变成一个抽象类
 }
 class Student extends Person
 {
     void study()
     {
         System.out.println("study");
     }
 }

一个练习如下：

定义员工类，其中有经理和工程师

class  abstractTest
 {
     public static void main(String[] args) 
     {
         Person p = new Person();
         p.study();
     }
 }
 abstract class Employee
 {
     private String name;
     private String id;
     private int pay;
     public Employee(String name,String id,int pay)
     {
         this.name=name;
         this.id=id;
         this.pay=pay;
     }
     public abstract void work();//每个员工都有工作方法，但是每种员工的方法都不一样，所以把工作函数定义为抽象方法，让每种员工都必须重写该方法才能调用。
 }
 class Manager extends Employee
 {
     private int bonus;
     public Manager(String name,String id,int pay,int bonus)
     {
         super(name,id,pay);//super直接使用父类的构造函数
         this.bonus=bonus;
     }
     public void work()//重写work方法
     {
         System.out.println("Manager work");
     }
 }
 class Engineer extends Employee
 {
     public Manager(String name,String id,int pay)
     {
         super(name,id,pay);
     }
     public void work()
     {
         System.out.println("Engineer work");
     }
 }

模版方法模式

什么是模板方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分不确定，而确定的部分使用不确定的部分

那么在这个时候就可以把不确定的部分暴露出去，由该类的子类来完成