设计模式(2)--工厂模式概念要点及例子说明

所谓的工厂模式，就是将对象的创建交给一个工厂类来管理创建，使用者不需要关注对象的创建，就能更好关注其业务使用
工厂模式又可以分为简单工厂模式，工厂方法模式和抽象工厂模式。

1. 简单工厂模式：

工厂的核心功能是生成电脑，所以有核心的抽象类或接口Computer
根据核心接口进行扩展，派生处具体的工厂产品，华为电脑(HWComputer)和苹果电脑(AppleComputer)

public interface Computer {

}

public class HWComputer implements Computer {

    public HWComputer() {
        System.out.println("This is Huawei Computer");
    }
}

public class AppleComputer implements Computer {
    public AppleComputer() {
        System.out.println("This is Apple Computer");
    }
}

简单工厂模式，靠一个工厂类来管理对象的创建，可依据不同产品的特性来实现不同产品的创建。比如品牌branch

public class SimpleComputerFactory {
    public Computer makeCommputer(String branch) {
        if ("huawei".equals(branch)) {
            return new HWComputer();
        } else if ("apple".equals(branch)) {
            return new AppleComputer();
        } else {
            return null;
        }
    }

    public static void main(String[] args) {
        SimpleComputerFactory factory = new SimpleComputerFactory();
        Computer HwComputer = factory.makeCommputer("huawei");
        Computer appleComputer = factory.makeCommputer("apple");
    }
}

通过工厂类统一的方法makeCommputer来管理具体产品的创建
但它的问题也很突出，当需要生产别的品牌电脑时，还需要对工厂类进行修改，这不符合开闭原则（对扩展开放，对修改关闭）
这就衍生出了工厂方法模式

2. 工厂方法模式：

工厂方法模式与简单工厂模式的区别在于产品的创建并非由工厂类来统一区分，而是由子工厂来管理创建。

工厂方法模式抽象产品、具体产品、抽象工厂和具体工厂等 4 个要素构成
 抽象产品：定义产品规范的接口，即Computer接口
 具体产品：实现抽象产品接口的产品，即HWComputer、AppleComputer
 抽象工厂：提供了创建产品的接口，即ComputerFactory
 具体工厂：实现抽象工厂的工厂，即HWComputerFactory、AppleComputerFactory

//工厂核心方法
public abstract class ComputerFactory {
    abstract Computer makeComputer();
}

//huawei电脑子工厂
public class HWComputerFactory extends ComputerFactory {
    @Override
    Computer makeComputer() {
        HWComputer hwComputer = new HWComputer();
//        hwComputer.setXXX();
        return hwComputer;
    }
}

//apple电脑子工厂
public class AppleComputerFactory extends ComputerFactory {
    @Override
    Computer makeComputer() {
        AppleComputer appleComputer = new AppleComputer();
//        appleComputer.setXXX();
        return appleComputer;
    }
}

public class ComputerFactoryTest {
    public static void main(String[] args) {
        HWComputerFactory hwComputerFactory = new HWComputerFactory();
        HWComputer hwComputer = (HWComputer) hwComputerFactory.makeComputer();

        AppleComputerFactory appleComputerFactory = new AppleComputerFactory();
        AppleComputer appleComputer = (AppleComputer) appleComputerFactory.makeComputer();
    }
}

主要针对工厂方法来进行扩展子工厂
这样，每当由新的品牌电脑需要生产，只需要开辟一个新的子工厂即可

3. 抽象工厂模式：

工厂方法模式只生产一个等级的产品，即拥有一个工厂核心方法
抽象工厂模式，是工厂方法模式的升级，拥有多个核心方法，即可生成多个等级的产品

一台电脑拥有不同的CPU、GPU等组件，这些组件的生成可以统一由抽象工厂ComponentFactory来管理
具体生产什么配置的电脑，由具体工厂来实现

//抽象产品
public interface CPU {
}

//具体产品Cpu_I5
public class Cpu_I5 implements CPU {
    public Cpu_I5() {
        System.out.println("this is i5 cpu.");
    }
}

//具体产品Cpu_I7
public class Cpu_I7 implements CPU {
    public Cpu_I7() {
        System.out.println("this is i7 cpu.");
    }
}

//抽象产品
public interface GPU {
}

//具体产品Gpu_AMD
public class Gpu_AMD implements GPU {
    public Gpu_AMD() {
        System.out.println("this is AMD gpu.");
    }
}

//具体产品Gpu_NVIDIA
public class Gpu_NVIDIA implements GPU {
    public Gpu_NVIDIA() {
        System.out.println("this is NVIDIA gpu.");
    }
}

//抽象工厂
public interface ComponentFactory {
    public CPU makeCpu();
    public GPU makeGpu();
}

//具体工厂LowComposePlant
public class LowComposePlant implements ComponentFactory {
    @Override
    public CPU makeCpu() {
        return new Cpu_I5();
    }

    @Override
    public GPU makeGpu() {
        return new Gpu_AMD();
    }
}

//具体工厂MiddleComposePlant
public class MiddleComposePlant implements ComponentFactory {
    @Override
    public CPU makeCpu() {
        return new Cpu_I7();
    }

    @Override
    public GPU makeGpu() {
        return new Gpu_NVIDIA();
    }
}

public class AppleComputerFactory extends ComputerFactory {
    @Override
    Computer makeComputer() {
        AppleComputer appleComputer = new AppleComputer();
        MiddleComposePlant middleComposePlant = new MiddleComposePlant();
        CPU cpu = middleComposePlant.makeCpu();
        GPU gpu = middleComposePlant.makeGpu();
        appleComputer.setCpu(cpu);
        appleComputer.setGpu(gpu);
        return appleComputer;
    }
}

4. 工厂模式的作用：

 【解耦】：不用关注实例是如何创建的，就能更好关注其业务使用

解耦就是把对象的创建和使用分开，比如上述创建一台中配的苹果电脑，只需要new AppleComputerFactory().makeComputer();即可
并不需要关注其内部CPU、GPU等组件的初始化，这样能更好的关注其业务使用
·
或者像CPU、GPU这也是工厂模式创建的，直接使用给appleComputer赋值即可，不用关注其如何创建
·
也许有人会说，我也可以直接在构造函数里面对实例进行初始化，这样不就可以不用创建那么多工厂的东西了吗
好像是这个道理，但你就需要创建对应的实体类对象，比如低配LowAppleComputer、中配MiddleAppleComputer、高配HightAppleComputer等等，
工厂模式的话可以进行扩展，增加实现方法即可，虽然一定程度会违反开闭原则。
·
设计模式这东西都是因地制宜，看情况使用

以上均为个人见解，欢迎讨论