设计模式之工厂模式

工厂模式

创建型模式

这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

介绍

意图: 定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

主要解决: 主要解决接口选择的问题。

何时使用: 我们明确地计划不同条件下创建不同实例时。

如何解决: 让其子类实现工厂接口,返回的也是一个抽象的产品。

关键代码: 创建过程在其子类执行。

应用实例: 1.您需要买披萨,可以直接去披萨店买,而不用去管披萨是怎么做出来的,以及这个披萨里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

具体实现

UML类图

第一步

创建披萨的制作步骤的抽象类

public abstract class Pizza {

    //pizza的名字
    protected String name;

    //准备原材料 , 不同的披萨不一样
    public abstract void prepare();

    public void bake() {
        System.out.println(name + " baking");
    }

    public void cut() {
        System.out.println(name + " cutting");
    }

    public void box() {
        System.out.println(name + " boxing");
    }

    public void setName(String name) {
        this.name = name;
    }
}

第二步

继承披萨的抽象类,制作不同的披萨

public class BJCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("北京奶酪pizza");
        System.out.println(name + "准备原材料");
    }
}
public class BJPepperPizza extends Pizza {

    @Override
    public void prepare() {
        setName("北京胡椒pizza");
        System.out.println(name + "准备原材料");
    }
}
public class LDCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("伦敦奶酪pizza");
        System.out.println(name + "准备原材料");
    }
}
public class LDPepperPizza extends Pizza {

    @Override
    public void prepare() {
        setName("伦敦胡椒pizza");
        System.out.println(name + "准备原材料");
    }
}

第三步

定义一个抽象工厂

public abstract class OrderPizza {

    //定义一个抽象方法,createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    // 构造器
    public OrderPizza() {
        Pizza pizza;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); //抽象方法,由工厂子类完成
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }

    // 写一个方法,可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

第四步

继承该抽象工厂 , 用来表示制作不同的披萨

public class LDOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }

}
public class BJOrderPizza extends OrderPizza {

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }

}

第五步

创建测试类

public class PizzaStore {

    public static void main(String[] args) {
        String loc = "bj";
        if (loc.equals("bj")) {
            //创建北京口味的各种Pizza
            new BJOrderPizza();
        } else {
            //创建伦敦口味的各种Pizza
            new LDOrderPizza();
        }
    }

}

总结

优点: 1. 一个调用者想创建一个对象,只要知道其名称就可以了. 2. 扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3. 屏蔽产品的具体实现,调用者只关心产品的接口。

缺点: 每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖.这并不是什么好事。

评论

暂无评论