工厂模式三大分类

 * 工厂模式：实现创建者和调用者的分离。
 * 分类：
 *   1.简单工厂模式
 *   2.工厂方法模式
 *   3.抽象工厂模式

简单工厂模式，就以造车为例：

首先有个车接口，有个跑的方法：

public interface Car {
    void run();
}

然后有两个实现类：

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

public class Byd implements Car{
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}

写一个车工厂：

/**
 * 简单工厂模式车工厂，如果有新车只能在这上面改代码，不利于扩展。
 */
public class CarFactory {
    public static Car getCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){
            return new Byd();
        }else{
            return null;
        }
    }
}

也可以这么写：

/**
 * 简单工厂第二种方式
 */
public class CarFactory3 {

    public static Car getAodi(){
        return new Audi();
    }

    public static Car getByd(){
        return new Byd();
    }
}

调用：

        Car c1 = CarFactory.getCar("奥迪");
        Car c2 = CarFactory.getCar("比亚迪");
        c1.run();
        c2.run();
        Car c4 = CarFactory3.getAodi();
        c4.run();

可以发现简单工厂模式代码简单，但不符合OCP。

面向对象设计的基本原则之一：OCP（开闭原则）：一个软件的实体应当对扩展开放，对修改关闭。

工厂方法模式：同样是造车，车接口和实现跟上面一样，省略。

写一个车工厂接口：

/**
 *工厂方法模式的车工厂，有新车只需新增车和对应的车工厂即可，开放扩展。
 */
public interface CarFactory2 {
    Car getCar();
}

然后写两个车对应的车工厂实现类：

public class AudiFactory implements CarFactory2{
    @Override
    public Car getCar() {
        return new Audi();
    }
}

public class BydFactory implements CarFactory2{
    @Override
    public Car getCar() {
        return new Byd();
    }
}

调用：

        //工厂方法
        Car c3 = new AudiFactory().getCar();
        c3.run();

可以发现，工厂方法解决了简单工厂的弊端，可扩展，但写的接口和类要多些。这两种模式。从理论上来说工厂方法较好，利于扩展，但实际上简单工厂用的多。

上面两种模式都是生产一种产品，下面这个抽象工厂模式就是生产产品族的。

 * 抽象工厂模式：用来生产不同产品族的全部产品。在有多个业务品种、业务分类时，
 *    通过抽象工作模式产生需要的对象是一种非常好的解决方式。
 *    产品族：比如发动机、轮胎、座椅、玻璃等生产出一辆车，这些一起的就是一个产品族。
 *    抽象工厂对于新增产品无能为力，只能新增产品族；新增产品还是交给简单工厂或工厂方法。

首先先有产品：

/**
 * 生产轮胎
 */
public interface Tyre {
    void revolve();
}
//高端
class LuxuryTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("磨损慢");
    }
}
//低端
class LowTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("磨损快");
    }
}
/**
 * 生产座椅
 */
public interface Seat {
    void massage();
}
//高端
class  LuxurySeat implements Seat{
    @Override
    public void massage() {
        System.out.println("座椅可以按摩");
    }
}
//低端
class  LowSeat implements Seat{
    @Override
    public void massage() {
        System.out.println("座椅不可以按摩");
    }
}
/**
 * 生产发动机
 */
public interface Engine {
    void run();
    void start();
}
//高端
class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("跑得快");
    }

    @Override
    public void start() {
        System.out.println("启动快");
    }
}
//低端
class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("跑得慢");
    }

    @Override
    public void start() {
        System.out.println("启动慢");
    }
}

然后写一个车工厂接口：

public interface CarFactory4 {
    Tyre getTyre();
    Seat getSeat();
    Engine getEngine();
}

两个实现类：

//低端车
public class LowCarFactory implements CarFactory4{
    @Override
    public Tyre getTyre() {
        return new LowTyre();
    }

    @Override
    public Seat getSeat() {
        return new LowSeat();
    }

    @Override
    public Engine getEngine() {
        return new LowEngine();
    }
}
//高端车
public class LuxuryCarFactory implements CarFactory4{
    @Override
    public Tyre getTyre() {
        return new LowTyre();
    }

    @Override
    public Seat getSeat() {
        return new LowSeat();
    }

    @Override
    public Engine getEngine() {
        return new LowEngine();
    }
}

调用：

        //抽象工厂
        CarFactory4 factory = new LowCarFactory();
        Engine engine=factory.getEngine();
        engine.start();
        engine.run();