4、设计模式之工厂模式

开始之前

本章节是一个系列，里面用的的代码实例都是连贯的。在实现某一种设计模式时，为了减少代码篇幅，前面博客出现model类（仅限公用的model类，比如compute、CPU、Mem、Disk等纯对象类）不会重复出现，读者在阅读某一篇博客时，如果发现突然出现了一个新的model类，在本片博客中没有其定义，可以往前面的博客翻一下！

最后，当本系列更新完成后，我会整个的代码完整贴出来，提供下载链接！

简单工厂模式

效果：用户不必关心对象怎么生产的，甚至不用关心这个具体对象是什么。
工厂的生产规则可以写入配置文件，这样修改时就不需要动代码了。

• 缺点：如果我们想让工厂再能多生产一种东西，那就要修改这个工厂类的方法。这显然不符合开闭原则。

public class HUAWEICompute extends Compute{

    @Override
    protected String getName() {
        return "huawei compute";
    }
}

public class MacCompute extends Compute{

    @Override
    protected String getName() {
        return "mac compute";
    }
}

/**
 * 简单工厂模式
 * 有一个缺点：如果我们想让工厂再能多生产一种东西，那就要修改这个工厂类的方法。这显然不符合开闭原则
 */
public class SimpleFactory {

/**第一种实现方式
*/
    public static Compute createCompute(String type){
        switch (type){
            case "HUAWEI":
                return new HUAWEICompute();
            case "MAC":
                return new MacCompute();
            case "XIAOMI":
                return new XiaomiCompute();
            default:
                return null;
        }
    }
/**第二种实现方式
*/
    public static Compute createCompute(Class<? extends Compute> clzss){
        try {
            return clzss.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

工厂方法模式

在简单工厂中，有一个缺点：如果我们想让工厂再能多生产一种东西，那就要修改这个工厂类的方法。这显然不符合开闭原则。
针对这个问题，所以引出了工厂方法模式。
在简单工厂模式中，不管生产什么品牌的鞋子，都用同一工厂。
而在工厂方法模式中，想要生产某一个品牌的鞋子，就使用其对应的工厂。
也就是说一个工厂只生产一种产品

• 缺点：一个工厂只能生产一种产品,子类越来越多，系统中类的个数也会成倍增加。增加代码复杂度

public interface ComputeFactory {

    Compute createCompute();
}

public class HuaweiComputeFactory implements ComputeFactory{
    @Override
    public Compute createCompute() {
        return new HUAWEICompute();
    }
}

public class XiaomiComputeFactory implements ComputeFactory{
    @Override
    public Compute createCompute() {
        return new XiaomiCompute();
    }
}

抽象工厂模式

在工厂方法模式中，

• 优点：增加分组非常简单，例如要增加Lenovo分组，只需创建Lenovo工厂和具体的产品实现类。
• 缺点：分组中的产品扩展非常困难，要增加一个鼠标Mouse，既要创建抽象的Mouse接口, 又要增加具体的实现：DellMouse、HPMouse， 还要再每个Factory中定义创建鼠标的方法实现。

public class HUAWEIDisk extends Disk{
    @Override
    protected String getName() {
        return "huawei disk";
    }
}

public class HUAWEICpu extends CPU{

    @Override
    protected String getName() {
        return "huawei cpu";
    }
}

public class HUAWEIMem extends Mem{

    @Override
    protected String getName() {
        return "huawei mem";
    }
}

public interface Factory {

    Compute createCompute();

    CPU createCpu();

    Mem createMem();

    Disk createDisk();
}

public class HuaweiFactory implements Factory{
    @Override
    public Compute createCompute() {
        return new HUAWEICompute();
    }

    @Override
    public CPU createCpu() {
        return new HUAWEICpu();
    }

    @Override
    public Mem createMem() {
        return new HUAWEIMem();
    }

    @Override
    public Disk createDisk() {
        return new HUAWEIDisk();
    }
}

public class XiaomiFactory implements Factory{
    @Override
    public Compute createCompute() {
        return new XiaomiCompute();
    }

    @Override
    public CPU createCpu() {
        return new XiaomiCpu();
    }

    @Override
    public Mem createMem() {
        return new XiaomiMem();
    }

    @Override
    public Disk createDisk() {
        return new XiaomiDisk();
    }
}

总结

• 简单工厂：唯一工厂类，一个产品抽象类，工厂类的创建方法依据入参判断并创建具体产品对象。
• 工厂方法：多个工厂类，一个产品抽象类，利用多态创建不同的产品对象，避免了大量的if-else判断。
• 抽象工厂：多个工厂类，多个产品抽象类，产品子类分组，同一个工厂实现类创建同组中的不同产品，减少了工厂子类的数量。