工厂模式

工厂模式：实例化对象不需要使用 new，用工厂方法代替，将调用者和实现类进行解耦

简单工厂模式

简单工厂模式：用来生产同一等级结构的任何产品（对于新增加的产品，需要修改已有的代码）

假设有一个接口汽车，有两个子类”Wuling“和”Tesila“分别实现了这个接口

public interface Car {
    void name();
}

public class Tesila implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

public class Wuling implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

那么 CarFactory 负责生产汽车

public class CarFactory {
    public static Car getCar(String s) {
        if ("五菱宏光".equals(s)) {
            return new Wuling();
        } else if ("特斯拉".equals(s)) {
            return new Tesila();
        } else {
             return null;
        }
    }
}

消费者购买汽车时，不需要关注汽车的实现细节（参数），只需要调用工厂中的方法即可。

public class Consumer {
    public static void main(String[] args) {
        Car car1 = CarFactory.getCar("五菱宏光");
        Car car2 = CarFactory.getCar("特斯拉");
        car1.name();  // 五菱宏光
        car2.name();  // 特斯拉
    }
}

以上就是简单工厂模式。

但是简单工厂模式并不符合开闭原则（对扩展开发，对修改关闭），因为每增加一个产品，都需要对工厂进行修改。

工厂方法模式

工厂方法模式：用来生产同一等级结构的固定产品（支持增加任意产品）

public interface Car {
    void name();
}

public class Tesila implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

public class Wuling implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

有一个汽车工厂接口，并且每一种型号的汽车对应一个工厂

public interface CarFactory {
    Car getCar();
}

public class WulingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Wuling();
    }
}

public class TesilaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesila();
    }
}

消费者从对应的工厂获取对应的车

public class Consumer {
    public static void main(String[] args) {
        Car car1 = new TesilaFactory().getCar();
        Car car2 = new WulingFactory().getCar();
        car1.name(); // 特斯拉
        car2.name(); // 五菱宏光
    }
}

工厂方法模式增加产品只需要创建新的类，不需要对代码进行修改，所以符合开闭原则。

每一个汽车的子类都对应一个工厂子类，利用多态特性动态创建对象的模式，就是工厂方法模式。

抽象工厂模式

假如产品不在只有一种，而是有多种不同的类型，那么抽象工厂模式更容易解决。

假设现在有两种产品，口罩和防护服，分为高端和低端。

// 口罩的接口
public interface Mask {
    void showMask();
}

public class LowMask implements Mask{
    @Override
    public void showMask() {
        System.out.println("我是低端口罩");
    }
}

public class HighMask implements Mask{
    @Override
    public void showMask() {
        System.out.println("我是高端口罩");
    }
}

// 防护服的接口
public interface Suit {
    void showSuit();
}

public class LowSuit implements Suit {
    @Override
    public void showSuit() {
        System.out.println("我是低端防化服");
    }
}

public class HighSuit implements Suit{
    @Override
    public void showSuit() {
        System.out.println("我是高端防护服");
    }
}

接下来是工厂类，分成了低端和高端两组。

public interface IFactory {
    // 创建口罩
    Mask createMask();

    // 创建防化服
    Suit createSuit();
}

public class HighFactory implements IFactory{
    @Override
    public Mask createMask() {
        return new HighMask();
    }

    @Override
    public Suit createSuit() {
        return new HighSuit();
    }
}

public class LowFactory implements IFactory{
    @Override
    public Mask createMask() {
        return new LowMask();
    }

    @Override
    public Suit createSuit() {
        return new LowSuit();
    }
}

消费者获取产品

public class Consumer {
    public static void main(String[] args) {
        HighFactory highFactory = new HighFactory();
        Mask mask1 = highFactory.createMask();
        Suit suit1 = highFactory.createSuit();

        LowFactory lowFactory = new LowFactory();
        Mask mask2 = lowFactory.createMask();
        Suit suit2 = lowFactory.createSuit();

        mask1.showMask();
        mask2.showMask();
        suit1.showSuit();
        suit2.showSuit();
    }
}

简单工厂模式：简单工厂模式有唯一的工厂类，工厂类的创建方法根据传入的参数做 if-else 条件判断，决定最终创建什么样的产品对象。

工厂方法模式：工厂方法模式由多个工厂类实现工厂接口，利用多态来创建不同的产品对象，从而避免了冗长的 if-else 判断。

抽象工厂模式：抽象工厂模式把产品子类再分组，同组中不同产品由同一个工厂子类的不同方法负责创建，从而减少了工厂子类的数量。