设计模式之模板模式和建造者模式

一、说明：我觉得模板模式真的没有什么东西，似乎只是简单的利用了继承，而且和建造者模式差不多。
二、模板模式定义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中，是的子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

    例子：比如制造一个产品X，需要先制作零件a，然后零件b，然后零件c，这样就设计一个AbstractProductX的抽象类，然后定定义零件a、b、c的制造方法，然后定义一个createProduct方法将三个零件做出来。

  class abstract AbstractProductX{
                   Abstract void a();
                   Abstract void b();
                   Abstractvoid c();
                    void createProduct(){
                        this.a();
                        this.b();
                        this.c();
                    } 
                }

将制造零件abc的具体方法延迟到子类中去实现，这样如果未来科技发展了以后导致a零件的制造方法改变了，那么只需要改变一下a()函数就可以了。而不会影响整体的框架。

建造者模式定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。（定义没看懂啊）
我个人的理解就是在模板模式的基础上使得框架方法中的执行顺序可以根据需要而改变。（也就是上面例子中的createProduct
函数中的几个函数执行顺序可以任意改变）。
例子：

抽象基础类

public abstract class AbstractProductX {
    protected abstract void createa();
    protected abstract void createb();
    protected abstract void createc();
    protected abstract void created();
    protected void createProduct(int[] order){
        for(int i=0;i<order.length;i++){
            if(order[i] == 0){
                this.createa();
            }else if (order[i] == 1) {
                this.createb();
            }else if (order[i] == 2) {
                this.createc();
            }else if (order[i] == 3) {
                this.created();
            }
        }
    }
}

具体实现类：Product1和Product2

public class Product1 extends AbstractProductX{

    @Override
    protected void createa() {
        System.out.println("1_a");
    }

    @Override
    protected void createb() {
        System.out.println("1_b");
    }

    @Override
    protected void createc() {
        System.out.println("1_c");
    }

    @Override
    protected void created() {
        System.out.println("1_d");
    }

}

public class Product2 extends AbstractProductX{

    @Override
    protected void createa() {
        System.out.println("2_a");
    }

    @Override
    protected void createb() {
        System.out.println("2_b");
    }

    @Override
    protected void createc() {
        System.out.println("2_c");
    }

    @Override
    protected void created() {
        System.out.println("2_d");
    }
}

既然叫建造者类当然就有建造者啦

public class Product1Builder {
    private Product1 product = new Product1();
    public Product1 getProduct(int[] order) {
        product.createProduct(order);
        return this.product;
    }
}

public class Product2Builder {
    private Product2 product = new Product2();
    public Product2 getProduct(int[] order) {
        this.product.createProduct(order);
        return this.product;
    }
}

还需要一个指挥者（不知道用了这个指挥者有什么好处?也许，如果原本设定的建造顺序发生变化，那么只需要在指挥者中去修改就可以了，而不需要到相应的建造者中去修改）

public class Director {
    private Product1Builder product1Builder = new Product1Builder();
    private Product2Builder product2Builder = new Product2Builder();
    public Product1 getProduct1() {
        System.out.println("制造product1");
        return product1Builder.getProduct(new int[]{0,1,2,3});
    }
    public Product2 getProduct2() {
        System.out.println("制造product2");
        return product2Builder.getProduct(new int[]{2,3,1,0});
    }
}

最后写一段代码测试一下：

Director director = new Director();
        director.getProduct1();
        director.getProduct2();

运行结果为：
制造product1
1_a
1_b
1_c
1_d
制造product2
2_c
2_d
2_b
2_a