【设计模式2】工厂模式

最新推荐文章于 2024-06-16 09:46:44 发布

stay_running

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量199

点赞数

文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_38602383/article/details/122525179

版权

【设计模式1】单例模式
 【设计模式2】工厂模式
 【设计模式3】原型模式
 【设计模式4】建造者模式

简单工厂模式

基本介绍

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
简单工厂模式：定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。
在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
定义一个可以实例化的Pizza类，封装创建对象的类，UML类图如下：

示例代码：
1，构建Pizza抽象类：

public abstract class 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;
    }
}

2，构建具体的pizza类

/**
 * 奶酪披萨 
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println(" 给制作奶酪披萨 准备原材料 ");
    }
}

/**
 * 希腊披萨 
 */
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println(" 给希腊披萨 准备原材料 ");
    }
}

/**
 * 胡椒粉披萨 
 */
public class PepperPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println(" 给胡椒披萨准备原材料 ");
    }
}

3，创建Pizza的工厂

/**
 * 简单工厂模式 -- 制造披萨对象
 */
public class SimplePizzaFactory {

    //更加orderType 返回对应的Pizza 对象
    public Pizza createPizza(String orderType) {

        Pizza pizza = null;

        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        } else if (orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }

        return pizza;
    }

    //简单工厂模式 也叫 静态工厂模式 
    public static Pizza createPizza2(String orderType) {

        Pizza pizza = null;

        System.out.println("使用简单工厂模式2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        } else if (orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }

        return pizza;
    }
}

4，订购pizza，通过pizza建造工厂创建pizza对象

import design.factory.simple.factory.SimplePizzaFactory;
import design.factory.simple.pizza.Pizza;

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

/**
 * 订购披萨 
 */
public class OrderPizza {

    //定义一个简单工厂对象
    SimplePizzaFactory simpleFactory;
    Pizza pizza = null;

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

    public void setFactory(SimplePizzaFactory simpleFactory) {
        String orderType = ""; //用户输入的

        this.simpleFactory = simpleFactory; //设置简单工厂对象

        do {
            orderType = getType();
            //通过工厂对象创建pizza对象
            pizza = this.simpleFactory.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 "";
        }
    }
}

5，pizza商店，购买pizza

/**
 * Pizza商店
 */
public class PizzaStore {

    public static void main(String[] args) {
        //使用简单工厂模式
        new OrderPizza(new SimplePizzaFactory());
        System.out.println("~~退出程序~~");

    }
}

简单工厂优缺点：
简单工厂模式提供专门的工厂类用于创建对象，实现了对象创建和使用的职责分离，客户端不需知道所创建的具体产品类的类名以及创建过程，只需知道具体产品类所对应的参数即可，通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。
但缺点在于不符合“开闭原则”，每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
为了解决简单工厂模式的问题，出现了工厂方法模式。

工厂方法模式

工厂方法模式：工厂方法模式将对象的实例化推迟到子类。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。

但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
示例：
UML类图
在这里插入图片描述
1，创建抽象pizza类：

/**
 * 披萨类--抽象 
 */
public abstract class 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;
    }
}

2，创建具体的披萨类：

/**
 * 北京奶酪披萨
 */
public class BJCheesePizza extends Pizza {

   @Override
   public void prepare() {
      setName("北京的奶酪pizza");
      System.out.println(" 北京的奶酪pizza 准备原材料");
   }

}

/**
 * 北京胡椒披萨
 */
public class BJPepperPizza extends Pizza {
   @Override
   public void prepare() {
      setName("北京的胡椒pizza");
      System.out.println(" 北京的胡椒pizza 准备原材料");
   }
}

/**
 * 伦敦奶酪披萨
 */
public class LDCheesePizza extends Pizza{

   @Override
   public void prepare() {
      setName("伦敦的奶酪pizza");
      System.out.println(" 伦敦的奶酪pizza 准备原材料");
   }
}

/**
 * 伦敦胡椒披萨
 */
public class LDPepperPizza extends Pizza{
   @Override
   public void prepare() {
      setName("伦敦的胡椒pizza");
      System.out.println(" 伦敦的胡椒pizza 准备原材料");
   }
}

3，创建构建pizza的工厂类：

/**
 * 北京Pizza工厂
 */
public class BJPizzaFactory {

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

/**
 * 伦敦pizza工厂
 */
public class LDPizzaFactory {

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

4，订购pizza

import design.factory.method.factory.BJPizzaFactory;
import design.factory.method.factory.LDPizzaFactory;
import design.factory.method.pizza.Pizza;

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

/**
 * 订购Pizza
 */
public class OrderPizza {

    private String pizzaLocation;
    private String pizzaType;

    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        do {
            getType();
            if (pizzaLocation.equalsIgnoreCase("BJ")) {
                BJPizzaFactory bjPizzaFactory = new BJPizzaFactory();
                pizza = bjPizzaFactory.createPizza(pizzaType);
            } else if (pizzaLocation.equalsIgnoreCase("LD")) {
                pizza = new LDPizzaFactory().createPizza(pizzaType);
            }
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }


    // 写一个方法，可以获取客户希望订购的披萨种类
    private void getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            pizzaType = strin.readLine();

            BufferedReader strin2 = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 产地:");
            pizzaLocation = strin2.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

5，披萨商店

public class PizzaStore {

    public static void main(String[] args) {
        new OrderPizza();
    }
}

抽象工厂模式

基本介绍

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

1，创建pizza类：抽象

/**
 * 披萨类--抽象 
 */
public abstract class 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;
    }
}

2，创建具体的披萨类：

/**
 * 北京奶酪披萨
 */
public class BJCheesePizza extends Pizza {

   @Override
   public void prepare() {
      setName("北京的奶酪pizza");
      System.out.println(" 北京的奶酪pizza 准备原材料");
   }

}

/**
 * 北京胡椒披萨
 */
public class BJPepperPizza extends Pizza {
   @Override
   public void prepare() {
      setName("北京的胡椒pizza");
      System.out.println(" 北京的胡椒pizza 准备原材料");
   }
}

/**
 * 伦敦奶酪披萨
 */
public class LDCheesePizza extends Pizza{

   @Override
   public void prepare() {
      setName("伦敦的奶酪pizza");
      System.out.println(" 伦敦的奶酪pizza 准备原材料");
   }
}

/**
 * 伦敦胡椒披萨
 */
public class LDPepperPizza extends Pizza{
   @Override
   public void prepare() {
      setName("伦敦的胡椒pizza");
      System.out.println(" 伦敦的胡椒pizza 准备原材料");
   }
}

3，创建工厂类

/**
 * 创建pizza的抽象工厂
 */
public interface PizzaFacotry {

    Pizza createPizza(String orderType);
}

/**
 * 北京Pizza工厂
 */
public class BJPizzaFactory implements PizzaFacotry {

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

/**
 * 伦敦pizza工厂
 */
public class LDPizzaFactory implements PizzaFacotry {

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

4，订购pizza

import design.factory.abs.factory.PizzaFacotry;
import design.factory.abs.pizza.Pizza;

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

public class OrderPizza {

    PizzaFacotry factory;
    private String pizzaType;

    // 构造器
    public OrderPizza(PizzaFacotry factory) {
        this.factory = factory;
        Pizza pizza = null;
        do {
            getType();
            pizza = factory.createPizza(pizzaType);
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }


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

}

5，pizza商店

public class PizzaStore {

    public static void main(String[] args) {
    //输入对应想创建披萨的工厂，构建对应的披萨
        new OrderPizza(new LDPizzaFactory());
    }
}

 工厂模式小结

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

stay_running

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【设计模式2】工厂模式

简单工厂模式基本介绍简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式：定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。定义一个可以实例化的Pizza类，封装创建对象的类，UML类图如下：示例代码：1，构建Pizza抽象类：public abs
复制链接

扫一扫