23种设计模式之简单工厂模式

简单工厂

简单工厂模式

---

简单工厂模式不是23种里的一种，简而言之，就是有一个专门生产某个产品的类。
比如下图中的鼠标工厂，专业生产鼠标，给参数0，生产戴尔鼠标，给参数1，生产惠普鼠标。

概述

---

简单工厂模式又称为静态工厂模式，它不属于23种设计模式 ，但现实中却经常会用到。

具体实现为定义一个类，该类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。其实就是将一个具体类的实例化交给一个类的静态方法来执行，该类被称为工厂类，静态方法被称为静态工厂方法，思想也非常简单。

参与角色

---

• 工厂（Factory）
  • 是简单工厂模式的核心，在工厂类中提供了静态工厂方法，它负责实现创建所有具体产品类的实例。工厂类可以被外界直接调用，创建所需的产品对象。
• 抽象产品（Abstract Product）
  • 它是所有具体产品角色的父类，它负责描述所有具体产品所共有的公共接口，抽象产品角色可以用一个Java接口或者Java抽象类实现。
• 具体产品（Concrete Product）
  • 继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。被创建出来的对象是该具体产品的实例。
• 图示
  
• 优势
  在简单工厂模式中，客户端工厂类来创建一个产品示例，而无需直接使用new关键字来创建对象，客户端只需要知道自己需要什么产品，如何来使用产品就可以了，具体的产品生产任务由具体的工厂类来实现。他是工厂模式家族中最简单的一员。

模式实现分析

案例一

• 实力分析
  你的女朋友，平时喜欢喝红茶、绿茶，因此你也掌握了这2种茶的制作方式，她想喝的时候你需要马不停蹄的做出来，并且端给她喝，有如下代码

  class RedTea {
    public RedTea(){
          System.out.println("我在制作红茶");
      }
  
      public void drinkRedTea(){
          System.out.println("喝红茶");
      }
      
      public void drinkRedTeaAfter(){
          System.out.println("喝红茶之后，开始收拾");
      }
  }
  
  class GreenTea {
    public GreenTea(){
          System.out.println("我在制作绿茶");
      }
  
      public void drinkGreenTea(){
          System.out.println("喝绿茶");
      }
      
      public void drinkGreenTeaAfter(){
          System.out.println("喝绿茶之后，开始收拾");
      }
  }
  
  

  今天她想喝红茶，所以你制作了红茶，并且端给她喝的时候告诉他这是红茶

  public class Demo1 {
    public static void main(String[] args) {
      RedTea redTea = new RedTea();
      redTea.drinkMilkTea();
    }
  }
  
  

  每次你做完后都会用不同的杯子装，后来你发现，红茶、绿茶都是茶，完全可以用一个杯子来装，并且这些茶的材料乱七八糟存放，为了统一管理，所以你引入了一个茶的概念

  //抽象产品
  abstract class Tea {
    abstract void drink();
      abstract void drinkAfter();
  }
  
  class RedTea extends Tea{
      
  }
  class GreenTea extends Tea{
      
  }
  
  

  这样你的操作更加规范，速度更快了，你女朋友觉得很幸福。但随着时间推移，你越来越忙，你就在想有没有红茶制作机器，直接将所有操作交给红茶机器去做，这样你只需要告诉红茶机器女朋友需要喝什么，就能够制作出相应的东西，这个时候你引入了红茶研磨机，这其实就是我们所说的工厂。

  class TeaFactory {
    public static Tea getTea(String teaName) throws Exception{
          if(teaName.equals("红茶")){
              return new RedTea();
          }else if(teaName.equals("绿茶")){
              return new GreenTea();
          }else{
              throw new Exception();
          }
    }
  }
  
  

  各种茶的类不变，仅仅是客户端发调用变了

  public class Demo1 {
    public static void main(String[] args) {
      //今天想喝绿茶
      try {
        Tea tea = TeaFactory.getTea("绿茶");
        tea.drink();
        tea.drinkAfter();
      } catch (Exception e) {
        System.out.println("不会做该茶");
      }
      
    }
  }
  
  

  我们可以看到，有了工厂之后，你再也不用自己手动去做了，你只需要告诉工厂，你女朋友要喝什么茶，研磨机就会自动将想要的茶给创建出来，这样我们在获取所需要的对象时会更加方便。

• 模式的缺点
  由于工厂类集中了所有产品创建逻辑，工厂类一般被我们称作“全能类”或者“上帝类”，因为所有的产品创建他都能完成，这看似是好事，但仔细想想是有问题的。比如全国上下所有的事情都有主席一个人干会不会有问题，当然有！一旦不能正常工作，整个系统都要受到影响。
  使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
  系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，
  不利于系统的扩展和维护。所以说从工厂的角度来说简单工厂模式是不符合“开-闭”原则的。 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构

• 适用场景
  在以下情况下可以使用简单工厂模式：
  工厂类负责创建的对象比较少：由于创建的对象少，不会造成工厂方法中的业务逻辑太复杂。
  客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型对应的参数即可。

• 在JDK中的应用
  JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

  public final static DateFormat getDateInstance();
  public final static DateFormat getDateInstance(int style);
  public final static DateFormat getDateInstance(int style,Locale locale);
  
  

案例二

📋 定义

一个工厂方法，依据传入的参数，生成对应的产品对象。

📋 角色

• 抽象产品
• 具体产品
• 具体工厂
• 产品的使用者

📋 使用说明

先将产品类抽离出来，比如：苹果和梨都是属于水果类，抽象出来一个水果类Fruit,苹果和梨就是具体的产品类，然后创建一个水果工厂。

📋 代码实现

• 水果接口

  public interface Fruit{
    void whatIm()
  }
  

• 苹果类

  public class Apple implements Fruit {  
      @Override  
      public void whatIm() {  
          System.out.println("苹果");  
      }  
  }  
  

• 梨类

  public class Pear implements Fruit {  
      @Override  
      public void whatIm() {  
          System.out.println("梨");  
      }  
  }  
  

• 水果工厂

  public class FruitFactory {
  
      publicFruitcreateFruit(Stringtype) {
  
          if (type.equals("apple")) {//生产苹果
              return new Apple();
          }
          elseif(type.equals("pear")) {//生产梨
              returnnewPear();
          }
  
          returnnull;
      }
  }
  

• 使用工厂产生的产品

  public class FruitApp {
  
      public static void main(String[] args) {
          FruitFactory mFactory = new FruitFactory();
          Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果  
          Pear pear = (Pear) mFactory.createFruit("pear");//获得梨  
          apple.whatIm();
          pear.whatIm();
      }
  }  
  

简单工厂的缺点

使用简单工厂创建对象，每当添加一种具体产品，就必然要修改工厂类，违反了开闭原则；
所以简单工厂适合产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适。

课后作业

• 适用简单工厂模式完成计算器+ - * /操作

• 要求：
  建立加减乘除4个具体类，能够计算并返回结果

  建立抽象类规范计算方法

  建立计算工厂类，用于获取对应的类实例，输入对应的类型获取不同实例