3.java设计模式之工厂模式

分类：设计模式作者：编程之家用户

基本需求：

  • 一个披萨店需要订购不同种类的披萨

传统方式：

  • 实现思路

    • 在订购类中根据用户不同的输入直接创建不同的披萨实体类进行返回

  • UML类图

  • 代码实现

    • 披萨类

      • // 抽象父类
public abstract class Pizza {

   String name;

   public abstract void prepare();

   public void bake() {
       System.out.println(this.name + "披萨烘焙中");
   }

   public void cut() {
       System.out.println(this.name + "披萨切割中");
   }

   public void box() {
       System.out.println(this.name + "披萨打包中");
   }

}

// 奶酪披萨 子类1
public class CheesePizza extends Pizza {

   public CheesePizza(String name) {
       this.name = name;
   }

   @Override
   public void prepare() {
       System.out.println(this.name + "披萨准备原材料中");
   }

}
// 希腊披萨 子类2
public class GreekPizza extends Pizza{

   public GreekPizza(String name) {
       this.name = name;
   }

   @Override
   public void prepare() {
       System.out.println(this.name + "披萨准备原材料中");
   }

}

    • 订购类

      • public class PizzaStore {

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

   // 订购披萨方法 传统方式直接采用new出子类的方法进行返回对应的披萨
   public void OrderPizza() {
       Pizza pizza;
       Scanner scanner = new Scanner(System.in);
       String orderType;
       while (true) {
           System.out.println("输入披萨的种类：");
           orderType = scanner.nextLine();
           if (StringUtils.equals("cheese",orderType)) {
               pizza = new CheesePizza("cheese");
           } else if (StringUtils.equals("greek",orderType)) {
               pizza = new GreekPizza("greek");
           } else {
               System.out.println("没有该类型的披萨");
               break;
           }
           pizza.prepare();
           pizza.bake();
           pizza.cut();
           pizza.box();
       }
   }

}

缺陷及改进：

  • 在订购方法中，直接采用new出子类的方法进行返回对应的披萨，违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码
  • 如果新增加一种类型的披萨，则需要修改OrderPizza的方法实现，如果有多个创建Pizza的方法则都需要修改
  • 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建Pizza对象的代码就不需要修改了——>简单工厂模式

简单工厂模式：

  • 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式

  • 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

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

  • 实现思路

    • 创建一个简单工厂类SimpleFactory，提供一个创建Pizza的方法，PizzaStore想要Pizza时，直接在工厂中获取即可

  • UML类图

  • 代码实现

    • // 简单工厂类 Pizza类及实现类同上
public class SimpleFactory {

   // 创建Pizza的方法 可在多个地方调用，如果需要增加其他种类的Pizza则只需要修改此方法内部的实现即可，不需要调用方
   public Pizza createPizza(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new CheesePizza("cheese");
       } else if (StringUtils.equals("greek",orderType)) {
           pizza = new GreekPizza("greek");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }

   // 简单工厂也叫静态工厂 可直接提供静态的方法获取对象
   public static Pizza createPizza1(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new GreekPizza("greek");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }
   
}

    • public class PizzaStore {

   public static void main(String[] args) {
       // new PizzaStore().OrderPizza();
       new PizzaStore(new SimpleFactory());
   }

   private SimpleFactory simpleFactory;

   public PizzaStore(SimpleFactory simpleFactory) {
       this.simpleFactory = simpleFactory;
       OrderPizza();
   }

   private void OrderPizza() {
       Pizza pizza;
       Scanner scanner = new Scanner(System.in);
       String orderType;
       while (true) {
           System.out.println("输入披萨的种类：");
           orderType = scanner.nextLine();
           // 通过Pizza工厂获取Pizza对象
           pizza = simpleFactory.createPizza(orderType);
           if (null == pizza) {
               break;
           }
           pizza.prepare();
           pizza.bake();
           pizza.cut();
           pizza.box();
       }
   }

}

工厂方法模式：

  • 在上面的基础上增加了新的需求，需要在每种pizza上加上产地，例如 北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza

  • 思路1：可以使用简单工厂模式，新建两个简单工厂，BJPizzaSimpleFactory和LDPizzaSimpleFactory 但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好

  • 思路2：采用工厂方法模式

    • 将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现
    • 工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

  • 实现思路

    • 在PizzaStore中增加一个创建Pizza抽象方法，由BJPizzaStore和LDPizzaStore去实现，至此该两个子类创建的Pizza都是各自地区的

  • UML类图

  • 代码实现

    • // 含有抽象方法的抽象类
public abstract class PizzaStore {

   public static void main(String[] args) {
       // 根据地区选工厂？ 没品出来和创建多个简单工厂有什么好处
       String area = "BJ";
       if (area.equals("BJ")) {
           new BJPizzaStore();
       } else {
           new LDPizzaStore();
       }
   }

   public PizzaStore() {
       OrderPizza();
   }

   private void OrderPizza() {
       Pizza pizza;
       Scanner scanner = new Scanner(System.in);
       String orderType;
       while (true) {
           System.out.println("输入披萨的种类：");
           orderType = scanner.nextLine();
           // 使用抽象方法来创建Pizza，使用不同的实现类将会得到不同的披萨
           pizza = createPizza(orderType);
           if (null == pizza) {
               break;
           }
           pizza.prepare();
           pizza.bake();
           pizza.cut();
           pizza.box();
       }
   }

   // 创建Pizza的抽象方法 由子类实现
   public abstract Pizza createPizza(String orderType);

}

    • // 子类1
public class BJPizzaStore extends PizzaStore {

   @Override
   public Pizza createPizza(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new BJCheesePizza("BJCheese");
       } else if (StringUtils.equals("pepper",orderType)) {
           pizza = new BJPepperPizza("BJPepper");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }
}

// 子类2
public class LDPizzaStore extends PizzaStore {

   @Override
   public Pizza createPizza(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new BJCheesePizza("LDCheese");
       } else if (StringUtils.equals("pepper",orderType)) {
           pizza = new BJPepperPizza("LDPepper");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }
}

抽象工厂模式：

  • 抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类,可以将简单工厂模式和工厂方法模式进行整合

  • 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象),将工厂抽象成两层，

  • 实现思路

    • 创建AbsFactory( 抽象工厂) 和具体实现的工厂子类，使用时创建工厂子类即可

  • UML类图

  • 代码实现

    • // 抽象工厂类
public interface AbsFactory {

   Pizza createPizza(String orderType);

}

// 子类1
public class BJFactory implements AbsFactory {

   @Override
   public Pizza createPizza(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new BJPepperPizza("BJPepper");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }

}

// 子类2
public class LDFactory implements AbsFactory {

   @Override
   public Pizza createPizza(String orderType) {
       Pizza pizza = null;
       if (StringUtils.equals("cheese",orderType)) {
           pizza = new BJPepperPizza("LDPepper");
       } else {
           System.out.println("没有该类型的披萨");
       }
       return pizza;
   }

}

    • public class PizzaStore {

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

   private AbsFactory factory;

   public PizzaStore(AbsFactory factory) {
       // 在此处声明需要工厂类对象 ， 使用时直接创建抽象工厂的子类对象即可
       this.factory = factory;
       OrderPizza();
   }

   private void OrderPizza() {
       Pizza pizza;
       Scanner scanner = new Scanner(System.in);
       String orderType;
       while (true) {
           System.out.println("输入披萨的种类：");
           orderType = scanner.nextLine();
           // 使用抽象方法来创建Pizza，使用不同的实现类将会得到不同的披萨
           pizza = factory.createPizza(orderType);
           if (null == pizza) {
               break;
           }
           pizza.prepare();
           pizza.bake();
           pizza.cut();
           pizza.box();
       }
   }

}

jdk源码：

  • 在Calendar类中的getInstance()方法中有用到简单工厂模式

  • public static Calendar getInstance()
   {
   	// 获取默认的zone和aLocale
       return createCalendar(TimeZone.getDefault(),Locale.getDefault(Locale.Category.FORMAT));
   }

public static Calendar getInstance(TimeZone zone,Locale aLocale)
   {
       return createCalendar(zone,aLocale);
   }

private static Calendar createCalendar(TimeZone zone,Locale aLocale)
   {
       CalendarProvider provider =
           LocaleProviderAdapter.getAdapter(CalendarProvider.class,aLocale)
                                .getCalendarProvider();
       if (provider != null) {
           try {
               return provider.getInstance(zone,aLocale);
           } catch (IllegalArgumentException iae) {
               // fall back to the default instantiation
           }
       }

       Calendar cal = null;
   	// 此处使用了简单工厂模式来创建Calender对象 通过aLocale不同的后缀
       if (aLocale.hasExtensions()) {
           String caltype = aLocale.getUnicodeLocaleType("ca");
           if (caltype != null) {
               switch (caltype) {
               case "buddhist":
               cal = new BuddhistCalendar(zone,aLocale);
                   break;
               case "japanese":
                   cal = new JapaneseImperialCalendar(zone,aLocale);
                   break;
               case "gregory":
                   cal = new GregorianCalendar(zone,aLocale);
                   break;
               }
           }
       }
   
       ......
           
       return cal;
   }

注意事项：

  • 意义：将实例化对象的的代码抽取出来，放到一个类中同一管理和维护，在项目中达到依赖解耦的目的，提高项目的扩展性和维护性
  • 依赖抽象原则（尽量依赖抽象的东西）
    • 创建对象时，不要使用new，而是将new的东西放在一个工厂中并返回
    • 不要让类继承一个具体的类，而是继承抽象类或者实现接口，不要覆盖基类汇总已经实现的方法

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

什么是设计模式？Design pattern--和生活结合更好理解
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引
面向对象设计原则一——单一职责原则
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
十分钟理解Java中的动态代理----强烈推荐
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的一些设计问题，总结出来的一套通用的解决方案。
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
外观模式-简化子系统的复杂性
外观模式又叫门面模式，它提供了一个统一的（高层）接口，用来访问子系统中的一群接口，使得子系统更容易使用。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方式处理个别对象和对象组合。
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候，所有依赖者都会自动收到通知。
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。
工厂模式-将对象的创建封装起来
工厂模式（Factory Design Pattern）可细分为三种，分别是简单工厂，工厂方法和抽象工厂，它们都是为了更好的创建对象。
状态模式-将状态和行为封装成对象
状态模式允许对象在内部状态改变时，改变它的行为，对象看起来好像改变了它的类。
命令模式-将请求封装成对象
命令模式将请求封装为对象，能够支持请求的排队执行、记录日志、撤销等功能。
【设计模式】备忘录模式
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。 基本介绍 **意图：**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该
【设计模式】职责链模式
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为
【设计模式】享元模式
享元模式（Flyweight Pattern）（轻量级）（共享元素）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot