模板模式

一.模板模式

模板模式:就是步骤的复用,将特性化的东西,交给子类去实现.

如果代码中有多段处理逻辑是一摸一样的代码,但却含有着各自特性的地方,就可以将步骤抽象出一个抽象类,将特性化的地方,用抽象方法代替,交由子类去实现各自特性化的东西.

二.模板模式-示例-水果榨汁

比方我们有苹果,西瓜,需要榨汁

1.不采用模板模式

public class LowTest {
    public static void main(String[] args) {
        // 获取水果
        String fruit = "苹果";
        //1.洗干净
        System.out.println("首先将["+fruit+"],洗干净!");
        //2.进行预处理根据水果的大小
        System.out.println("将苹果削皮去核后,切成块");
        System.out.println("获得处理后的:块状苹果");
        //3.放入榨汁机
        System.out.println("放入榨汁机!");
        System.out.println("获得:[苹果汁]");
        System.out.println("==============================");
        // 获取水果
        fruit = "西瓜";
        //1.洗干净
        System.out.println("首先将["+fruit+"],洗干净!");
        //2.进行预处理根据水果的大小
        System.out.println("将西瓜切片去皮,选取好看的五块西瓜");
        System.out.println("五块西瓜");
        //3.放入榨汁机
        System.out.println("放入榨汁机!");
        System.out.println("获得:[西瓜汁]");
    }
}

运行结果:(1.步骤,3.步骤是可以复用的,而2步骤却需要根据水果的不同而进行不同处理)

2.采用模板模式进行代码重构

1.创建一个榨汁抽象类--将获取水果,以及步骤2都变成抽象方法,交由子类实现

public abstract class JuiceTemplate {

    public String juicing(){
        // 获取水果
        String fruit = this.getFruit();
        //1.洗干净
        System.out.println("首先将["+fruit+"],洗干净!");
        //2.进行预处理根据水果的大小
        String s = this.preHandler();
        System.out.println("获得处理后的:"+s);
        //3.放入榨汁机
        System.out.println("放入榨汁机!");
        return "获得:["+fruit+"汁]";
    }

    protected abstract String getFruit();

    // 将具体处理方式,交由子类实现
    protected abstract String preHandler();

}

2.创建苹果汁榨汁类

public class AppleJuice extends JuiceTemplate {

    @Override
    protected String preHandler() {
        System.out.println("将苹果削皮去核后,切成块");
        return "块状苹果";
    }

    @Override
    protected String getFruit() {
        return "苹果";
    }
}

3.创建西瓜榨汁类

public class WatermelonJuice extends JuiceTemplate {
    @Override
    protected String getFruit() {
        return "西瓜";
    }

    @Override
    protected String preHandler() {
        System.out.println("将西瓜切片去皮,选取好看的五块西瓜");
        return "五块西瓜";
    }

}

4.创建测试类

public class Test {
    public static void main(String[] args) {
        System.out.println(new AppleJuice().juicing());
        System.out.println(new WatermelonJuice().juicing());
    }
}

5.运行结果:

首先调用变的简单,如果新增一种果汁,执行要继承榨汁类,实现预处理,以及获取水果方法,就可以使用榨汁模板获取果汁了

6.UML图

3.是否能采用接口的方式实现模板模式?

1.新建一IJuice接口

public interface IJuice {

    String getFruit();

    String preHandler();
}

2.新建JuiceTemplate类--从构造方法中传入实现IJuice的类

public class JuiceTemplate {

    private IJuice iJuice;

    public JuiceTemplate(IJuice iJuice) {
        this.iJuice = iJuice;
    }

    public String juicing(){
        // 获取水果
        String fruit = iJuice.getFruit();
        //1.洗干净
        System.out.println("首先将["+fruit+"],洗干净!");
        //2.进行预处理根据水果的大小
        String s = iJuice.preHandler();
        System.out.println("获得处理后的:"+s);
        //3.放入榨汁机
        System.out.println("放入榨汁机!");
        return "获得:["+fruit+"汁]";
    }
}

3.新建苹果类实现IJuice接口

public class AppleJuice implements IJuice {

    @Override
    public String preHandler() {
        System.out.println("将苹果削皮去核后,切成块");
        return "块状苹果";
    }

    @Override
    public String getFruit() {
        return "苹果";
    }
}

4.新建西瓜类实现IJuice接口

public class WatermelonJuice implements IJuice {
    @Override
    public String getFruit() {
        return "西瓜";
    }

    @Override
    public String preHandler() {
        System.out.println("将西瓜切片去皮,选取好看的五块西瓜");
        return "五块西瓜";
    }

}

5.新建测试类

public class Test {
    public static void main(String[] args) {
        System.out.println(new JuiceTemplate(new AppleJuice()).juicing());
        System.out.println("=================");
        System.out.println(new JuiceTemplate(new WatermelonJuice()).juicing());
    }
}

6.测试结果-----测试结果,与模板模式一样... ... 但在调用中,是根据传入的实体类是苹果还是西瓜,来决定是榨苹果汁还是西瓜汁的

7.UML图

通过UML图对比就会发现其实和策略模式一毛一样... ...

========>策略模式<=========

四.总结

模板模式:就是通过固定算法模型,将其中特性的部分,做成抽象方法,延迟到子类去实现的一种设计模式

其优点:

1.代码复用性提高

缺点:

1.固定住了算法模型,也就是必须按照写好的算法逻辑走,如果逻辑改变就需要重写算法模型