设计模式：工厂模式

核心本质：实现了创建者和调用者的分离。将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实 现类解耦。本质是让各个模块分工干活

　　面向对象设计的基本原则（了解下。。呵呵）：

　　　　　　 OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开 放，对修改关闭。

　　　　　　 DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程， 不要针对实现编程。

                       LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和 陌生人通信

　　分类

　　　　1.简单工厂：静态工厂，通过接收的参数的不同来返回不同的对象实例。（新增不同会修改代码）

　　　　2. 工厂方法: 也被称作多态性工厂。

　　　　3. 抽象工厂: 也叫工具箱模式。

 一：简单工厂

　　　　这里来引入一个创建产品模型，模拟简单工厂生成。

public interface Car {

    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

public class ChangAn implements Car {
    @Override
    public void run() {
        System.out.println("长安");
    }
}

public class CarFactory {

    public Car createCar(String type){
        if("audi".equals(type)){
            return new Audi();
        }else if("changan".equals(type)){
            return new ChangAn();
        }
        return null;
    }
}

public class Client01 {
    public static void main(String[] args) {
        Car car1 = CarFactory.createCar("audi");
        Car car2 = CarFactory.createCar("changan");
        car1.run();
        car2.run();
    }
}

　　可见，汽车工厂提供了一个工厂方法，在客户端调用下，这个方法创建客户端所需要的汽车，如果不是请求不是所能支持的，就返回null/

　　总结：简单工厂模式就是由一个工厂类根据传入的类型来决定创建出哪种产品的实例。再者简单工厂模式对于增加新产品无能为力！不修改代码的话，是无法扩展的。

二 工厂方法（类的创建模式）：目的是定义一个创建对象的工厂接口，将实际工作推迟到子类中去。

　　创建工厂方法接口

public interface CarFactory {
    Car createCar();
}

创建产品工厂方法

public class AudiFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Audi();
    }

}

public class ChangAnFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new ChangAn();
    }

}

public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new ChangAnFactory().createCar();
        
        c1.run();
        c2.run();
    }
}

工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目 或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类（也就是使用了多态性）.

　　ps: java Collection接口iterator()方法就是一个工厂方法，以及 操作数据库获取连接等操作都是。

三 抽象工厂模式

　　前面两种工厂是解决的单一产品等级结构，对于多个产品结构复杂度就会比较高，而抽象工厂主要是解决多个产品等级结构的系统。

　　例如汽车，有高端， 中端， 低端等不同产品（构成多个产品等级）。 采用简单工厂方法思考模式就会就3个工厂接口。每个工厂接口中抽象方法其实是一致的。这里把这几个工厂接口再做抽象就是抽象工厂模式

 　　还是用汽车例子： 

　　　　假设汽车由发动机和座椅组成，不同的定位产生不同的汽车构成汽车的一个产品族。

public interface Engine {
    void run();
    void start();
}

/**
 * 合资
 */
class ExternalEngin implements Engine{

    @Override
    public void run() {
        System.out.println("合资 run");
    }

    @Override
    public void start() {
        System.out.println("合资  start");
    }
}

/**
 * 国产
 */
class InternalEngin implements Engine{

    @Override
    public void run() {
        System.out.println("国产 run");
    }

    @Override
    public void start() {
        System.out.println("国产  start");
    }
}

public interface Engine {
    void run();
    void start();
}

/**
 * 合资
 */
class ExternalEngin implements Engine{

    @Override
    public void run() {
        System.out.println("合资 run");
    }

    @Override
    public void start() {
        System.out.println("合资  start");
    }
}

/**
 * 国产
 */
class InternalEngin implements Engine{

    @Override
    public void run() {
        System.out.println("国产 run");
    }

    @Override
    public void start() {
        System.out.println("国产  start");
    }
}

　　

/**
 * 抽象汽车工厂
 */
public interface CarFactory {

    Engine createEngin();

    Seat createSeat();
}

　　

/**
 * 合资汽车工厂
 */
public class ExternalCarFactory implements CarFactory {
    @Override
    public Engine createEngin() {
        return new ExternalEngin();
    }

    @Override
    public Seat createSeat() {
        return new ExternalSeat();
    }
}

　　

/**
 * 国产汽车工厂
 */
public class InternalCarFactory implements CarFactory {
    @Override
    public Engine createEngin() {
        return new InternalEngin();
    }

    @Override
    public Seat createSeat() {
        return new InternalSeat();
    }
}

　　

public class Client {
    public static void main(String[] args) {
        //合资汽车
        CarFactory exFactory = new ExternalCarFactory();
        exFactory.createEngin();
        exFactory.createSeat();

        //国产汽车
        CarFactory factory = new ExternalCarFactory();
        factory.createEngin();
        factory.createSeat();
    }
}

　　整个抽象工厂模式涉及：

　　　　抽象工厂角色（CarFactory）, 具体工厂类（ExternalCarFactory）,抽象产品（由 Engin和Seat构成）， 具体产品（ExternalCar...）这几个角色。

　　ps: 当某个系统产品有多个产品所构成的产品族，而系统之关注消费某一族的产品时可以考虑抽象工厂。