Java设计模式学习 - 模版方法模式&策略模式

设计模式-模板方法&策略模式

简单介绍

模板方法模式（Template）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

策略模式（Strategy）：定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。

定义公共方法，创建一个工厂，通过策略模式，让它的子类可以根据策略相互替换。

举个🌰

一群小动物要出门秋游，每个动物一开始都要准备出门远行的物品，不过不同动物穿的衣服和出门方式不同，例如酷酷的雪纳瑞，穿的是时髦的当季衣服，出门方式是小轿车；机智的拉布拉多，穿的是朴素的T恤，骑着拉风的小电驴；还有富有的🐶，穿的是钻石风衣，乘着🚁出门。

从上所述，可以抽象出一个总的动作：出门秋游，然后分成三个步骤：

一致的：

准备出门远行的物品

不一致的：

穿衣服
交通工具

代码设计

接口

/**
 * @author JingQ at 2018/9/8
 */
public interface IAutumnOuting {
    /**
     * 定义总的操作，返回值可以按实际设定
     * @param animalName 小动物
     */
    void outing(String animalName);
}

抽象模板

public abstract class AbstractAutumnOuting implements IAutumnOuting{
    @Override
    public void outing(String animalName) {
        step1(animalName);
        step2();
        step3();
    }
    /**
     * 公共操作
     * @param animalName    小动物的名字
     */
    private void step1(String animalName) {
        System.out.println("I'm preparing goods : " + animalName);
    }
    /**
     * 差异化操作
     */
    abstract void step2();
    /**
     * 差异化操作
     */
    abstract void step3();
}

模板1 - 酷酷的雪纳瑞

@Service
public class SchnauzerAutumnOuting extends AbstractAutumnOuting {
    @Override
    void step2() {
        System.out.println("I'm a cool cool schnauzer, wear fashionable clothes（时尚时尚最时尚）");
    }
    @Override
    void step3() {
        System.out.println("I'm a cool cool schnauzer, driving the small car（搽亮我的小汽车模型）");
    }
}

模板2 - 机智的拉布拉多

@Service
public class SchnauzerAutumnOuting extends AbstractAutumnOuting {
    @Override
    void step2() {
        System.out.println("I'm a cool cool schnauzer, wear fashionable clothes（时尚时尚最时尚）");
    }
    @Override
    void step3() {
        System.out.println("I'm a cool cool schnauzer, driving the small car（搽亮我的小汽车模型）");
    }
}

模板3 - 🐶

@Service
public class SingleAutumnOuting extends AbstractAutumnOuting {
    @Override
    void step2() {
        System.out.println("you're a single, want to travel everywhere");
    }
    @Override
    void step3() {
        System.out.println("you're a single, and will be very powerful");
    }
}

工厂-策略模式

/**
 * @author JingQ at 2018/9/8
 */
@Service
public class AutumnOutingFactory {
    @Autowired
    @Qualifier("schnauzerAutumnOuting")
    private AbstractAutumnOuting schnauzerAutumnOuting;
    @Autowired
    @Qualifier("labradorAutumnOuting")
    private AbstractAutumnOuting labradorAutumnOuting;
    @Autowired
    @Qualifier("singleAutumnOuting")
    private AbstractAutumnOuting singleAutumnOuting;
    public AbstractAutumnOuting getInstance(String type) {
        switch (type) {
            case "1":
                return schnauzerAutumnOuting;
            case "2":
                return labradorAutumnOuting;
            case "3":
                return singleAutumnOuting;
            default:
                return singleAutumnOuting;
        }
    }
}

执行效果

从执行效果可以看出，通过策略模式（类似switch操作），工厂判断出真正执行的对象，然后模板方法中，step1是公有的，step2和step3是子类中差异化实现的操作。

从控制台的打印结果可以看出，三个小动物的step操作都顺利执行了，而且代码的逻辑性看起来更强了。