工厂模式

工厂模式：提供了一种创建对象的最佳方式。创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式
分类

简单工厂：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）

工厂方法：用来生产同一等级架构中的固定产品。（支持增加扩展产品）

抽象工厂：用来生产不同产品族的全部产品。（不支持扩展增加产品，支持增加扩展产品）
优点：
1. 降低程序的耦合性

将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

简单工厂模式(Simple Factory Pattern)

又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

代码实例

/* 定义产品类 */
public interface Car {
    public void Run();
}

/* 定义产品1 */
public class Bmw implements Car{
    @Override
    public void Run(){
        System.out.println("宝马");
    }
}

/* 定义产品2 */
public class AoDi implements Car{
    @Override
    public void Run() {
        System.out.println("奥迪");
    }
}

/* 核心工厂类 */
public class CarFactory {
    public static Car createCar(String name){
        if("".equals(name)){
            return null;
        }
        if(name.equals("宝马")){
            return new Bmw();
        }
        if(name.equals("奥迪")){
            return new AoDi();
        }
        return null;
    }
}

/* 调用 */
public class Demo {
    public static void main(String[] args){
        Car aoDi = CarFactory.createCar("奥迪");
        Car bmw = CarFactory.createCar("宝马");
        aoDi.Run();
        bmw.Run();
    }
}

单工厂的优点/缺点

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化

缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

工厂方法模式(Factory Method)

工厂方法模式，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节

代码实例

/* 定义产品类 */
public interface Car {
    public void Run();
}

/* 创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法）*/
public interface CarFactory {
    Car createCar();
}

/* 创建工厂得商品 */
public class Bmw implements Car{
    @Override
    public void Run(){
        System.out.println("宝马");
    }
}

/* 创建工厂方法调用实例得接口 */
public class BmwFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Bmw();
    }    
}

/* 创建工厂得商品 */
public class AoDi implements Car{
    @Override
    public void Run() {
        System.out.println("奥迪");
    }
}

/* 创建工厂方法调用实例得接口 */
public class AoDiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new AoDi();
    }    
}

/*调用*/
public class Demo {
    public static void main(String[] args){
        Car bmw = new BmwFactory().createCar();
        Car aoDi = new AoDiFactory().createCar();
        bmw.Run();
        aoDi.Run();
    }
}

抽象工厂模式

抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品

创建子工厂

public interface Car {
    void run();
}
class CarA implements Car{
    @Override
    public void run(){
        System.out.println("小鹏");
    }
}
class CarB implements Car{
    @Override
    public void run(){
        System.out.println("蔚来");
    }
}

public interface Engine{
    void run();
}
class EngineA implements Engine{
    @Override
    public void run(){
        System.out.println("转得块");
    }
}
class EngineB implements Engine{
    @Override
    public void run(){
        System.out.println("转得慢");
    }
}

创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）

public interface TotalFactory {
    //创建汽车
    Car cretateChair();
    //创建引擎
    Engine createEngine();
    //总工厂实现类，由此决定调用哪个工厂实现哪个实例
}
class TotalFactoryRrally implements TotalFactory{
    @Override
    public Car cretateChair(){
        return new CarA();
    }
    @Override
    public Engine createEngine(){
        return new EngineA();
    }
}

调用

public class Demo {
    public  static void main(String[] args) {
        TotalFactory f = new TotalFactoryRrally();
        Car car = f.cretateChair();
        System.out.println(car);
        car.run();
        Engine engine = f.createEngine();
        System.out.println(engine);
        engine.run();
    }
}