工厂模式

概述

在父类中提供一个创建对象的方法，允许子类决定实例化对象的类型。

使用场景

假设一家汽车制造公司，一直在使用一套程序生产比亚迪型号的汽车，现在出现了大批量的特斯拉汽车的订单，如果在原来的程序上进行修改的话就会违反开闭原则，同时如果后期又多了其他品牌的订单，则再原程序上修改显得不现实。

解决方法

该公司分开出来两个制造工厂，BYDFactory和TeslaFactory，去分别制造该类型的汽车。公司接到订单后，只需要派给不同的公司即可。

实现

// 抽象工厂类接口
public interface CarFactory {
    public Car produce();
}

// 抽象产品类接口
// public interface Car {
    String show();
}

// 特斯拉工厂
public class TeslaFactory implements CarFactory{
    @Override
    public Car produce() {
    		// 只生产特斯拉
        return new TeslaCar();
    }
}

// 比亚迪工厂
public class BYDFactory implements CarFactory{
    @Override
    public Car produce() {
    		// 只生产比亚迪
        return new BYDCar();
    }
}

// 比亚迪汽车
public class BYDCar implements Car{
    @Override
    public String show() {
        return "Build Your Dream";
    }
}

// 特斯拉汽车
public class TeslaCar implements Car{
    @Override
    public String show() {
        return "Go Electric";
    }
}

// 制造汽车
public class Client {
    public static void main(String[] args) {
        // 不关心创建过程，只关心调用者是谁
        Car car = new BYDFactory().produce();
        String show = car.show();
        System.out.println(show);
    }
}

总结

需要有抽象工厂类和抽象产品类，工厂类生产各自的产品。
遵循开闭原则，不会对原程序进行修改。
单一功能指责，每个工厂的职责互不影响，比如特斯拉制造的四驱系统，比亚迪制造后驱系统。
缺点就是可能随着品牌增多，导致具体工厂类和具体产品类数量变多。

抽象工厂模式

概述

能创建一系列相关对象，而不需要制定具体类。

使用场景

电脑组装厂要组装联想和戴尔品牌的电脑，两种品牌的电脑采用的CPU、内存、硬盘都是不一样的厂家，如果不区分使用一套程序去制造非常困难，而且后期CPU换了型号，还要对应用程序大动手脚。

解决方法

应当采用抽象工厂模式，抽象出一条整链的原材料，如果后期修改的话对于上一层调用的地方不用修改，只需要修改具体工厂的方法。比如联想将CPU换为AMD只需要修改联想厂家的方法。

实现

// 抽象工厂
public interface ComputerFactory {
    CPU createCpu();

    Memory createMemory();
}

// 抽象产品
public interface CPU {
    void work();
}

public interface Memory {
    default void work() {
        System.out.println("默认内存");
    }
}

// 具体产品
public class IntelCpu implements CPU{
    @Override
    public void work() {
        System.out.println("intel CPU");
    }
}

public class AppleCpu implements CPU{
    @Override
    public void work() {
        System.out.println("apple cpu");
    }
}

// 具体工厂
public class DellFactory implements ComputerFactory {
		// apple cpu
    @Override
    public CPU createCpu() {
        return new AppleCpu();
    }

    @Override
    public Memory createMemory() {
        return new Memory() {
        };
    }
}


public class LenovoFactory implements ComputerFactory {
		// intel cpu
    @Override
    public CPU createCpu() {
        return new IntelCpu();
    }

    @Override
    public Memory createMemory() {
        return new Memory() {
        };
    }
}


public class Client {
    public static void main(String[] args) {
    		// 抽象工厂可以生产不同具体类一系列产品
        DellFactory factory = new DellFactory();
        factory.createCpu().work();
        factory.createMemory().work();
    }
}

总结

与普通工厂模式的区别就是每一个工厂不是创建单个对象，而是创建多个对象。