阅读 204

Java设计模式:工厂设计模式

简单工厂模式

基本介绍

1) 简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式;
2) 简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码);
3) 在软件开发中,当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式。

一个简单的需求

一个披萨的项目:要便于披萨种类的扩展,要便于维护
1) 披萨的种类很多(比如 GreekPizz、CheesePizz 等);
2) 披萨的制作有 prepare,bake, cut, box;
3) 完成披萨店订购功能。

传统的方式

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 CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("为CheesePizza准备原材料");
    }
}

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("为GreekPizza准备原材料");
    }
}

public class OrderPizza {//根据用户的输入创建对象
    public OrderPizza(){
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.name = "希腊披萨";
            }else if (orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.name = "奶酪披萨";
            }else {
                System.out.println("--退出程序--");
                break;
            }
            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 PizzaStore {//相当于一个客户端,发出订单
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}
复制代码

传统的方式的优缺点

1) 优点是比较好理解,简单易操作;
2) 缺点是违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增
加新功能的时候,尽量不修改代码,或者尽可能少修改代码。
**分析**:修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,往往有多处。
**思路**:把创建Pizza对象封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了。

使用简单工厂模式

  1. 简单工厂模式的设计方案: 定义一个可以实例化Pizaa对象的类,封装创建对象的代码。

  2. 代码演示:

    public class SimplePizzaFactory {//编写简单工厂 public Pizza createPizza(String type) { Pizza pizza = null; if (type.equals("cheese")) { pizza = new CheesePizza(); pizza.name = "奶酪披萨"; } else if (type.equals("greek")) { pizza = new GreekPizza(); pizza.name = "希腊披萨"; } return pizza; } }

public class OrderPizza {//重新编写OrderPizza类,其他类不变
//    定义一个简单工厂对象
    SimplePizzaFactory simplePizzaFactory;
//    构造器
    public OrderPizza(SimplePizzaFactory simplePizzaFactory){
        setFactory(simplePizzaFactory);
    }
    public void setFactory(SimplePizzaFactory simplePizzaFactory) {
        String orderType;//用户输入的披萨类型
        Pizza pizza = null;
        this.simplePizzaFactory = simplePizzaFactory;//设置简单工厂对象
        do {
            orderType = getType();
            pizza = this.simplePizzaFactory.createPizza(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                break;
            }
        }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 "";
        }
    }
}
复制代码

工厂方法模式

工厂方法模式介绍

       定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

一个新的需求 

披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如 北京的奶酪pizza、
北京的胡椒pizza 或者是伦敦的奶酪pizza、伦敦的胡椒pizza。
**工厂方法模式设计方案:**将披萨项目的实例化功能抽象成抽象方法,在不同的口味点
餐子类中具体实现。

使用工厂方法模式

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 class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        name = "北京奶酪 Pizza";
        System.out.println("北京奶酪Pizza 准备材料~~~~");
    }
}

public class BJPepperPizza extends Pizza{
    @Override
    public void prepare() {
        name = "北京胡椒 Pizza";
        System.out.println("北京胡椒Pizza 准备材料~~~~");
    }
}

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        name = "伦敦奶酪 Pizza";
        System.out.println("伦敦奶酪Pizza 准备材料~~~~");
    }
}

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        name = "伦敦胡椒 Pizza";
        System.out.println("伦敦胡椒Pizza 准备材料~~~~");
    }
}

public abstract class OrderPizza {

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

//    构造器    
public OrderPizza(){
        String orderType;//用户输入的披萨类型
        Pizza pizza = null;
        do {
            orderType = getType();
            pizza = createPizza(orderType);
//            输出pizza制作过程
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                break;
            }
        }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 BJOrderPizza extends OrderPizza {//继承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 LDOrderPizza extends OrderPizza {//继承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 PizzaStore {//相当于一个客户端,发出订单
    public static void main(String[] args) {
        new BJOrderPizza();
        System.out.println("--退出程序--");
    }
}
复制代码

抽象工厂模式

基本介绍

1) 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类;
2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合;
3) 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象);
4) 将工厂抽象成两层,AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。

使用抽象工厂模式

Pizza及其继承类BJCheesePizza、BJPepperPizza、LDCheesePizza、LDPepperPizza不变

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
//    让下面的工厂子类去具体实现
    public Pizza createPizza(String orderType);
}

//这是一个工厂子类
public class BJFactory implements AbsFactory {
    @Override
    public 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 LDFactory implements AbsFactory{
    @Override
    public 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 OrderPizza {
    AbsFactory factory;
    OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }
    private void setFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";//用户输入
        this.factory = factory;
        do {
            orderType = getType();
            pizza = factory.createPizza(orderType);
//            输出pizza制作过程
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败!");
                break;
            }
        }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 PizzaStore {//相当于一个客户端,发出订单
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
    }
}
复制代码

工厂模式小结

1) 工厂模式的意义:将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2)三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
3) 设计模式的依赖抽象原则
  • 创建对象实例时,不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中,并返回。有的书上说,变量不要直接持有具体类的引用。
  • 不要让类继承具体类,而是继承抽象类或者是实现interface(接口)
  • 不要覆盖基类中已经实现的方法。

注:本文章大量借鉴尚硅谷公开视频资料的内容,如有不妥之处立即删除。对文章有不懂的地方,可以直接去尚硅谷的官方网站学习。