模板设计模式

模板设计模式是比较简单，也容易理解的，简单来讲，就是一个事情的完成，要分为多个步骤来进行，但是不同的实现类，有不同的实现过程，可以自己去实现，但是步骤的顺序不能变

举个例子：
比如说,做饭，要经过三个步骤：
1.买菜
2.炒菜
3.端上餐桌

那这个1、2、3顺序是不可以变的，但是不同的人，
买菜的方式不同，有些人是网上下单购买，有些人是自己线下购买
炒菜：有些人是电磁炉炒菜，有些人是煤气灶炒菜
所以，模板设计模式，其实就是在父类中，规定了一个功能的先后步骤，但是具体每个步骤怎么实现，有子类去实现，如果某一个步骤是公用的，那可以放在父类实现

换算到我们框架中对模板设计模式的使用，AQS就是一个典型的模板设计模式

java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {
  if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

上面这个方法是reentrantLock加锁时，调用的一个方法，可以看到，aqs规定了，在加锁的时候，
1、需要先执行尝试加锁的步骤，加锁成功，就结束
2、如果没有加锁成功，就去排队

这就是aqs抽象的父类方法，不管是哪个类，集成了AQS去加锁的时候，都是这个执行顺序，只是，对于公平锁、非公平锁在尝试加锁的时候(tryAcquire)，可能有不同的逻辑，那就在自己的实现类中去实现就可以了

因为代码比较多，就不贴代码了，可以去jdk源码中看下

public abstract class AbstractParent {

    public void test() {
        A();
        B();
        if (isBuild()) {
            C();
        }
    }

    abstract void A();

    abstract void B();

    public void C() {
        System.out.println("这是C方法");
    }

    public boolean isBuild() {
        return true;
    }
}


public class Test01 extends AbstractParent {

    @Override
    public void A() {
        System.out.println("test01的A方法");
    }

    @Override
    void B() {
        System.out.println("test01的B方法");
    }

    @Override
    public void C() {
        System.out.println("这是test01的C()方法");
    }
}


public class Test02 extends AbstractParent {
    @Override
    public void A() {
        System.out.println("test02的A方法");
    }

    @Override
    void B() {
        System.out.println("test02的B方法");
    }
}



public class TemplateTest {
    public static void main(String[] args) {
        AbstractParent abstractParent = new Test01();
        AbstractParent abstractParent1 = new Test02();

        abstractParent.isBuild();

        abstractParent.test();
        System.out.println("");
        abstractParent1.test();
    }
}

上面这个就是我自己写的demo

个人感觉模板设计模式，可以将所有子类通用的逻辑沉淀在父类中，对于每个子类都不一样的方法，放在各个子类去实现，这样可以避免一部分重复的代码