一、基本概念

作用：实现创建者和调用者分离

核心本质：实例化对象不使用new，用工厂方法代替
将选择实现类，创建对象统一管理和控制，从而将调用者和实现类解耦

二、三种工厂模式

1、简单工厂

简单工厂也叫静态工厂模式，一般是使用静态方法，通过接受不同的参数来返回不同的实例

缺点：对增加新的产品无能为力，只能通过修改已有的类或者已有的方法来进行扩展，例如下面如果新增一个保时捷，那么我们的CarFactory类就要修改原有代码了，不符合开闭原则，所以我们后面使用工厂方法模式规避此问题

开闭原则指的是软件实体应该通过扩展（例如新增类）来实现变化，而不是修改已有的代码（修改已有的方法或者类）

public interface Car {
    void showName();
}

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

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

// 简单工厂模式
public class CarFactory {
    // 使用静态方法，通过接受不同的参数来返回不同的实例
    public static Car createCar(String name) {
        if ("比亚迪".equals(name)) {
           return new Byd();
        } else if ("奥迪".equals(name)) {
            return new Audi();
        } else {
            return null;
        }
    }
}

// 这种也是简单工厂模式的体现
public class CarFactory02 {
    public static Car createByd() {
        return new Byd();
    }
     public static Car createAudi() {
        return new Audi();
    }
}


// 简单工厂情况下，获取对象实例
public class Client {
    public static void main(String[] args) {
        // 通过调用工厂类来获取对象实例
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

        c1.showName();
        c2.showName();
    }
}

2、工厂方法模式

工厂方法模式和简单工厂模式最大的不同：
简单工厂模式只有一个工厂类，而工厂方法模式有一组实现了相同接口的工厂类

public interface Car {
    void showName();
}

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

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

public interface CarFactory {
    Car createCar();
}

//返回奥迪类实例
public class AudiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Audi();
    }
}

//返回比亚迪类实例
public class BydFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Byd();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();

        c1.showName();
        c2.showName();
    }
}

3、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）：
是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂，重点理解什么是产品族

产品等级结构：即产品的继承结构，如一个抽象类是轮胎，其子类有高端轮胎和低端轮胎，则轮胎与具体级别的轮胎之间构成了一个产品等级结构

产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，例如下面例子中高端车工厂生产的轮胎、引擎和座椅就可以看成一个产品族

举个例子，我们有一个超级汽车工厂，这个工厂高端车和低端车都生产

为了方便管理，我们需要造出两个子工厂，专门负责生产高端车和低端车

public interface CarFactory {
    Engine createEngine();

    Seat createSeat();

    Tire createTire();
}

public class LowerFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LowerEngine();
    }

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

    @Override
    public Tire createTire() {
        return new LowerTire();
    }
}

public class AdvancedFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new AdvancedEngine();
    }

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

    @Override
    public Tire createTire() {
        return new AdvancedTire();
    }
}

子工厂又有专门生产座椅、引擎和轮胎的二级工厂

public interface Engine {
    void engineInfo();
}

class AdvancedEngine implements  Engine {
    @Override
    public void engineInfo() {
        System.out.println("高端引擎");
    }
}

class LowerEngine implements Engine {
    @Override
    public void engineInfo() {
        System.out.println("低端引擎");
    }
}
===============================================
public interface Seat {
    void seatInfo();
}

class AdvancedSeat implements Seat {
    @Override
    public void seatInfo() {
        System.out.println("高端座椅");
    }
}

class LowerSeat implements  Seat {
    @Override
    public void seatInfo() {
        System.out.println("低端座椅");
    }
}
===============================================
public interface Tire {
    void tireInfo();
}

class AdvancedTire implements Tire {
    @Override
    public void tireInfo() {
        System.out.println("高端轮胎");
    }
}

class LowerTire implements  Tire {
    @Override
    public void tireInfo() {
        System.out.println("低端轮胎");
    }
}

超级工厂只需要调用相应子工厂就可以生产高端车和低端车了

public class Client {
    public static void main(String[] args) {
        CarFactory carFactory = new AdvancedFactory();
        Engine engine = carFactory.createEngine();
        engine.engineInfo();
    }
}

如有错误，欢迎指正！