抽象类模板设计模式相关知识总结

抽象类：抽象类只是在普通类的基础上扩充了一些抽象方法，所谓的抽象方法指的是只声明而未实现的方法（没有方法体），所有抽象方法要求使用abstract来定义，并且抽象方法所在的类一定要使用abstract关键字来定义，表示抽象类。
抽象类中包含由抽象方法，而抽象方法不包含方法体，既没有具体实现。因此抽象类不能直接生产实例。

abstract class Person{
    private String name;//属性
    //普通方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //抽象方法
    abstract public void getPersonInfo();

}

对于抽象类的使用原则：
1.抽象类不可以被实例化
2.所有抽象类必须有子类
3.抽象类的子类必须覆写抽象类的所有抽象方法（子类不是抽象类）

class Student extends Person{

    @Override
    public void getPersonInfo() {
        System.out.println("i am a student");
    }
}

方法覆写一定要考虑权限问题，权限尽量都用public
派生类的访问权限必须大于等于基类的访问权限（重写方法的时候）
public>protected>包访问权限>private（访问权限修饰符）
4.抽象类的对象可以通过对象多态性利用子类为其实例化
5.private与abstract不能同时使用（final修饰的类和方法不可以被修改）
6.如果一个类是抽象类，继承了抽象类，作为派生类的抽象类可以不实现基类抽象类的方法
7.抽象类中可以包含非抽象方法
模板设计模式：
开闭原则（OCP）：一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。
咖啡冲泡法：

1. 将水煮沸
2. 用沸水冲泡咖啡
3. 将咖啡倒进杯子
4. 加糖和牛奶

class Coffee{
    public void boilWater(){
        System.out.println("1.将水煮沸");
    }
    public void brewCoffeeGrings(){
        System.out.println("2.用沸水冲泡咖啡");
    }
    public void pourInCup(){
        System.out.println("3.将咖啡倒进杯子");
    }
    public void addSugarAndMilk(){
        System.out.println("4.加糖和牛奶");
    }
    public void function1(){
        boilWater();
        brewCoffeeGrings();
        pourInCup();
        addSugarAndMilk();

    }
}
public class TextDemo2 {
    public static void main(String[] args) {
        Coffee coffee = new Coffee();
        coffee.function1();
    }
}

茶冲泡法：

1. 将水煮沸
2. 用沸水浸泡茶叶
3. 把茶倒进杯子
4. 加柠檬

class Tea{
    public void boilWater(){
        System.out.println("1.将水煮沸");
    }
    public void steepTeaBag(){
        
        System.out.println("2.用沸水浸泡茶叶");
    }
    public void pourInCup(){
        
        System.out.println("3.将茶倒进杯子");
    }
    public void addLemon(){
        System.out.println("4.加柠檬");
    }
    public void function2(){
        boilWater();
        steepTeaBag();
        pourInCup();
        addLemon();
    }

}
public class TextDemo3 {
    public static void main(String[] args) {
        Tea tea = new Tea();
        tea.function2();
    }

}

重新设计一个版本：

1. 将水煮沸
2. 用热水泡饮料
3. 把饮料倒进杯子
4. 在饮料内加⼊适当的调料

abstract class Drink {
     void boilWater() {
        System.out.println("1.将水煮沸");
    }
    abstract void brew();
     void pourInCup()
     {
        System.out.println("3.倒进杯子");
    }
    abstract void addSomething();
    final void function3(){
        boilWater();
        brew();
        pourInCup();
        addSomething();
    }
}
class Coffee1 extends Drink {

    @Override
    void brew() {
        System.out.println("2.浸泡咖啡");

    }
    @Override
    void addSomething() {
        System.out.println("4.加糖和牛奶");
    }
}
class Tea1 extends Drink{

    @Override
    void brew() {
        System.out.println("2.浸泡茶叶");
    }
    @Override
    void addSomething() {
        System.out.println("4.加柠檬");
    }
}
public class TextDemo4 {
    public static void main(String[] args) {
        Coffee1 coffee1 = new Coffee1();
        coffee1.function3();
        Tea1 tea1 = new Tea1();
        tea1.function3();
    }
}

钩子方法是一类"默认不做事的方法"
子类可以视情况决定要不要覆盖它们。