设计模式--工厂模式

1.工厂模式简介

工厂模式分为简单工厂模式，工厂方法模式和 抽象工厂模式 ，它们都属于设计模式中的创建型模式。其主要功能都
是帮助我们把对象的实例化部分抽取了出来，目的是降低系统中代码耦合度，并且增强了系统的扩展性。本文对这
三种模式进行了介绍并且分析它们之间的区别。
下面看下简单工厂模式的实现步骤：

1.1简单工厂模式

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最
大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代
码将会非常复杂。

step01-创建汽车接口

包含一个run()方法

 public interface Car {
  /*** 汽车运行的接口方法 */
   void run(); 
   }

steo02-创建三个汽车实现类

汽车类实现汽车接口，并重写run（）方法

public class Benz implements Car {
@Autowired
    public void run() {
        System.out.println("奔驰 is running！");
    }
}

public class Bike implements Car {
@Autowired
    public void run() {
        System.out.println("我只有自行车！");
    }
}

public class Bmw implements Car {
@Autowired
    public void run() {
        System.out.println("宝马 is running！");
    }
}

step03-构造汽车工厂

汽车工厂包含一个创建汽车的getCar()方法，方法内部根据传入的参数，进行对象的创建

public class CarFactory {
    public static Car getCar(String type){
        if("benz".equalsIgnoreCase(type)){
            //其中可能有很复杂的操作 
            return new Benz();
        } else if("bmw".equalsIgnoreCase(type)){
            //其中可能有很复杂的操作
            return new Bmw(); 
        }else {
            return new Bike(); 
        } 
    } 
}

step04-测试简单工厂

(1)先看下不使用工厂模式时，创建对象及调用方法的方式：

public class Client {
    public static void main(String[] args) {
        Car bmw = new Bmw();
        bmw.run();
        Car benz = new Benz(); 
        benz.run();
    }
}

(2)使用简单工厂模式时，调用对象方法的方式：

//使用简单工厂方法，获取对象
public class simpleFactoryDemo{
    public static void main(String[] args) {
        Car bmw = CarFactory.getCar("bmw"); 
        bmw.run();
        Car benz = CarFactory.getCar("benz");
        benz.run(); 
    } 
}

注意：
1.可能有人会问，使用简单工厂模式，代码量比不使用工厂模式要复杂为什么还要使用呢？
这个问题，其实是因为这个示例比较简单，试想，在car接口的方法有N个时（一个汽车可能会有很多的方法），这样在调用的时候就需要每个都set（）方法进行调用，代码冗余就很明显了。
2.在工厂类中的getCar()方法内部，传值不仅仅可以传String类型的参数，也可以传Class类，如下代码：

public class CarFactory {
    public static Car getCar(Class clazz){
        if("benz".equalsIgnoreCase(clazz.getName())){
            //其中可能有很复杂的操作
            return new Benz();
        } else if("bmw".equalsIgnoreCase(clazz.getName())){
            //其中可能有很复杂的操作
            return new Bmw();
        }else {
            return new Bike();
        }
    }
}

//参数为类
public class simpleFactoryDemo{
    public static void main(String[] args) {
        Car bmw = CarFactory.getCar(Bmw.class); 
        bmw.run();
        Car benz = CarFactory.getCar(Benz.class);
        benz.run(); 
    } 
}

1.2工厂方法模式

java开发中要遵循开闭原则，如果将来有一天我想增加一个新的车，那么必须修改CarFactory工厂类，就不太灵活。
解决方案是使用工厂方法模式。

何为工厂方法模式？

拿创建汽车的案例来讲，当有一天需要增加一个新车时，比如Audi，简单工厂模式中需要在carFactory工厂类的getCar()方法内部增加一个Audi的判断进行对象的创建。而工厂方法模式，顾名思义，将原有的几个车公用一个工厂类，改为每个车都有自己的工厂类，这样，在新增车辆Audi时，只需要新增一个Audi自己的工厂类，进而进行对象的创建即可。
下面看下具体步骤：

step01-创建工厂的抽象接口

首先，将原有的carFactory工厂类抽象出一个工厂接口

public interface Factory {
    /*** 统一的创建方法 * @return */ 
    Car create(); 
}

step02-针对每一个产品构建一个工厂方法

BenzFactoryl类

public class BenzFactory implements Factory {
    public Car create() {
        //中间省略一万行代码 
         return new Benz(); 
    } 
}

新增Audi时

public class AudiFactory implements Factory {
    public Car create() {
        //中间省略一万行代码 
         return new Audi(); 
    } 
}

step03-测试工厂方法模式

public class methodFactoryDemo{
    public static void main(String[] args) {
        //先实例化工厂类
        Factory benzFactory = new BenzFactory(); 
        //调用工厂类中creat()方法创建对象
        Car benz = benzFactory.create(); 
        //调用run()方法
        benz.run(); 
        
        Factory audiFactory = new BmwFactory(); 
        Car bmw = audiFactory.create(); 
        audi.run(); 
    } 
}

简单工厂模式和工厂方法模式的对比与选择：

工厂方法模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作需要到其工厂
子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当
系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩
展性变得很好，符合面向对象编程的开闭原则。

工厂方法模式虽然扩展性好，但是增加了编码难度，大量增加了类的数量，所以怎么选择还是看实际的需求。

1.3抽象工厂模式（暂不介绍）