JAVA设计模式-工厂设计模式

追逐路上的小人物

已于 2022-10-06 23:42:53 修改

阅读量539

点赞数

分类专栏： JAVA 文章标签： java 设计模式开发语言

于 2022-10-06 17:22:33 首次发布

本文链接：https://blog.youkuaiyun.com/CB_Beginner/article/details/127184306

版权

JAVA 专栏收录该内容

105 篇文章

订阅专栏

1、举例

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

1) 披萨的种类很多 ( 比如 GreekPizz 、 CheesePizz 等 )

2) 披萨的制作有 prepare ， bake, cut, box

3) 完成披萨店订购功能。

package com.cb.design.design.factory.order;

import com.cb.design.design.factory.CheesePizz;
import com.cb.design.design.factory.GreekPizz;
import com.cb.design.design.factory.PepperPizza;
import com.cb.design.design.factory.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类是，只需要修改
 * 该类就可，其他有创建到Pizza对象的代码就不需要修改了
 * 简单工厂模式
 *
 * @author chenbiao
 * @Data 2022/10/6 4:22 PM
 */
public class OrderPizza {

    //构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizz();
                pizza.setName("希娜");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizz();
                pizza.setName("中式");
            } else if(orderType.equals("hujiao")){
               pizza=new PepperPizza();
               pizza.setName("胡椒");
            }
            //输出piaaz 制作过程
            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 "";
        }
    }
}

2、基本介绍

1、简单工厂模式是由一个工厂对象决定创建出那一种产品类的实例。

2、定了一个创建对象的类，由这个类来封装实例化对象的行为

3、当我们会用到大量的创建某种，某类或者某批对象时，就可以使用工厂模式

3、使用简单工厂模式

/**
 * 简单工厂类 也叫静态工厂模式
 * 简单工厂模式就是把 逻辑里生成实例的代码抽取到工厂里面。返回实例。
 * 在实现的方法里面，只处理实例的方法。这样就不会污染实现实例的方法。
 * @author chenbiao
 * @Data 2022/10/6 4:50 PM
 */
public class SimpleFactory {

    //更具orderType 返回Pizza
    public Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizz();
            pizza.setName("希娜");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizz();
            pizza.setName("中式");
        } else if(orderType.equals("hujiao")){
            pizza=new PepperPizza();
            pizza.setName("胡椒");
        }else if(orderType.equals("A")){
            pizza=new APizzs();
            pizza.setName("A");
        }

        return pizza;
    }
}

public class OrderPizza {

    //构造器
//    public OrderPizza() {
//        Pizza pizza = null;
//        String orderType;//订购披萨的类型
//        do {
//            orderType = getType();
//            if (orderType.equals("greek")) {
//                pizza = new GreekPizz();
//                pizza.setName("希娜");
//            } else if (orderType.equals("cheese")) {
//                pizza = new CheesePizz();
//                pizza.setName("中式");
//            } else if(orderType.equals("hujiao")){
//               pizza=new PepperPizza();
//               pizza.setName("胡椒");
//            }
//            //输出piaaz 制作过程
//            pizza.prepare();
//            pizza.bake();
//            pizza.cut();
//            pizza.box();
//        } while (true);
//    }
    SimpleFactory simpleFactory;//聚合的方式
    Pizza pizza = null;

    //构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void  setFactory(SimpleFactory simpleFactory){
        String orderType="";
        this.simpleFactory=simpleFactory;//设置简单工厂对象
        do{
            orderType=getType();
             pizza = this.simpleFactory.createPizza(orderType);
            if(this.pizza !=null){
                this.pizza.prepare();
                this.pizza.box();
                this.pizza.cut();
                this.pizza.bake();
            }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 "";
        }
    }
}

4、使用静态工厂模式

public class SimpleFactory2 {

    //更具orderType 返回Pizza
    public static Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用简单工厂模式2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizz();
            pizza.setName("希娜");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizz();
            pizza.setName("中式");
        } else if(orderType.equals("hujiao")){
            pizza=new PepperPizza();
            pizza.setName("胡椒");
        }else if(orderType.equals("A")){
            pizza=new APizzs();
            pizza.setName("A");
        }

        return pizza;
    }
}

public class OrderPizza2 {
    Pizza pizza = null;
    String orderType="";
    //构造器
    public OrderPizza2() {
        do{
            orderType=getType();
            pizza = SimpleFactory2.createPizza(orderType);
            if(this.pizza !=null){
                this.pizza.prepare();
                this.pizza.box();
                this.pizza.cut();
                this.pizza.bake();
            }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 "";
        }
    }
}

总结：原先不符合OCP原则

把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类是，只需要修改。该类就可，其他有创建到Pizza对象的代码就不需要修改，

简单工厂模式就是把 逻辑里生成实例的代码抽取到工厂里面。返回实例。在实现的方法里面，只处理实例的方法。这样就不会污染实现实例的方法。

5、使用工厂方法模式

例子：

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪 pizza 、

北京的胡椒 pizza 或者是伦敦的奶酪 pizza 、伦敦的胡椒 pizza 。

5.1、使用工厂方法模式设计（相当各个子类去实现抽象方法）

将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类重具体实现

5.2、工厂方法模式：

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

public abstract class OrderPizza {



    //顶一个抽象方法，让各个类去实现
    abstract Pizza createPizza(String orderType);

    //构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购披萨的类型
        do {
            orderType = getType();
             pizza = createPizza(orderType);//抽象方法，由工厂子类去完成（接口呢？）
            //输出piaaz 制作过程
            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 BJOrderPiaaz extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza=null;
        if(orderType.equals("pizza")){
            pizza=new BJPizzaPizz();
        }
        return pizza;
    }
}

总结：

新增加一层，让工厂变为抽象，主要是去if else 判断。让实现或继承的类去实现抽象方法

6、抽象工厂模式

6.1、抽象工厂模式：定义了一个interface用于创建相关或者有依赖关系的对象族，而无需指明具体的类

6.2、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合

6.3、将工厂抽象成两层，抽象工厂和具体的实现的工厂子类，可以根据创建对象类型使用对应的工厂子类，这样将单个简单工厂变为工厂族。更利于代码的维护和扩展

public class OrderPizza {
    AbsFactory factory;

    public OrderPizza(AbsFactory factory){
        setFactory(factory);
    }
    
    public void setFactory( AbsFactory absFactory){
        Pizza pizza = null;
        this.factory=absFactory;

        do{
            String type = getType();
            //factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(type);
            if(pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.box();
                pizza.cut();
            }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 "";
        }
    }
}

/**
 * 就是把抽象类改为接口实现的另外一种实现
 * @author chenbiao
 * @Data 2022/10/6 11:20 PM
 */
public interface AbsFactory {
    public Pizza createPizza(String orderType);
}

总结。

由继承抽象类变为实现接口

选择：当产品类很多。可以使用多个抽象工厂。当产品类就几个。可以使用简单工厂模式