设计模式（一）：简单工厂模式

设计模式（一）：简单工厂模式

一、定义

简单工厂模式是属于类的创建型模式，又叫静态工厂方法模式。通过专门定义一个类来创建其他类的实例，就好比与一个我们生活中的工厂一样，并且被创建的实例通常都具有相同的父类

二、简单实现

我们先定义一个Apple和Banana的类，里面都只有一个get方法

//苹果类
public class Apple {
    public void get(){
        System.out.println("采集苹果");
    }
}
//香蕉类
public class Banana {
    public void get(){
        System.out.println("采集香蕉");
    }
}

1. 先不用简单工厂模式，就按照我们平时的代码写

   public static void main(String[] args) {
           Apple apple=new Apple();
           apple.get();
           Banana banana=new Banana();
           banana.get();
   }
   

2. 再用简单工厂模式实现一下，不过在这之前，还得先定义一个Fruit（水果）父类—里面定义一个get方法，让Apple和Banana继承它并重写get方法，然后再创建一个FruitFactory工厂类（用于创建水果实例）

   //水果工厂
   public class FruitFactory {
       public static Fruit getApple(){
           return new Apple();
       }
       public static Fruit getBanana(){
           return new Banana();
       }
   }
   

   public static void main(String[] args) {
           Fruit apple = FruitFactory.getApple();
           apple.get();
           Fruit banana = FruitFactory.getBanana();
           banana.get();
   }
   

   通过两个测试main方法，我们可以看出简单工厂模式的好处，虽然代码都是四行，但是代表的意义却不一样，FruitFactory这个工厂类把实例化对象这种逻辑处理隐藏到了工厂类的方法里，使得整个代码的可读性，可拓展性更好

3. 其实，我们感觉FruitFactory里面的getApple和getBanana方法都差不多，还可以把两个方法封装成一个方法

   public class FruitFactory {
       //分装成一个方法
       public static Fruit getFruit(String fruitName) throws Exception {
           Fruit fruit=null;
           switch (fruitName){
               case "apple":
                   fruit=new Apple();
                   break;
               case "banana":
                   fruit=new Banana();
                   break;
               default:
                   throw new Exception("创建水果实例失败");
           }
           return new Apple();
       }
   }
   

   public static void main(String[] args){
           try {
               Fruit apple = FruitFactory.getFruit("apple");
               apple.get();
               Fruit banana = FruitFactory.getFruit("banana");
               banana.get();
               //若输入字符串错误，则抛出“创建水果实例失败”
               Fruit banana = FruitFactory.getFruit("bananaaa");
           }catch (Exception e){
               e.printStackTrace();
           }
   }
   

4. 在任何时候，输入字符串来判断都是一种不安全的手段，因为经常可能会被写错，但是编译器又不会报错提示，因此为了杜绝这种情形，我们还可以使用反射机制来优化上一段代码

   public static Fruit getFruit(Class cls) throws Exception{
           if (Apple.class==cls){
               return Apple.class.newInstance();
           }else if (Banana.class==cls){
               return Banana.class.newInstance();
           }else {
               throw new Exception("创建水果实例失败");
           }
   }
   

   public static void main(String[] args){
           try {
               Fruit apple = FruitFactory.getFruit(Apple.class);
               apple.get();
               Fruit banana = FruitFactory.getFruit(Banana.class);
               banana.get();
           }catch (Exception e){
               e.printStackTrace();
           }
   }
   

三、总结

• 该模式中包含的角色以及职责：
  1. 工厂（Creator）：是简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以直接被外部调用，创建所需产品对象
  2. 抽象角色（Product）：简单工厂模式所有创建对象的父类，可以是接口亦可以是抽象类，它负责描述所有实例所共有的公共接口
  3. 具体产品（Concrete Product）：简单工厂模式所创建的具体实例对象
• 优缺点：
  • 优点：用户使用的时候可以直接调用工厂类的方法来创建所需实例对象，而不需要知道这些对象是如何创建以及如何组织的。有利于整个软件体系的优化。
  • 缺点：正所谓，成也萧何，败也萧何。简单工厂模式的确定也体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所在在“高内聚”方面做得不好。另外，当系统中的具体产品类不断增多时，需要频繁修改工厂类的方法，拓展性不够好。