设计模式1：工厂模式

0 序言

当创建对象需要一系列复杂的初始化操作如关联其他成员对象、查配置文件、查数据库表的时候，把这些功能放在构造函数就不太合适了。
这时候就需要使用工厂帮助我们创建对象。

1、简单工厂模式

有唯一的工厂类，工厂类的创建方法根据传入的参数做if-else判断，决定最终创建什么样的对象。

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

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

class SimpleFactory{
    public Mask createMask(String type){
        Mask mask=null;
        if("lowend".equals(type)){
            mask=new LowEndMask();
        }else if("highend".equals(type)){
            mask=new HighEndMask();
        }
        return mask;
    }
}
public class testSimpleFactoryPattern {
    public static void main(String[] args) {
        SimpleFactory factory=new SimpleFactory();
        Mask mask = factory.createMask("lowend");
        mask.showMask();
    }
}

//结果是：
低端口罩

2、工厂方法模式

面向对象的开闭原则：对扩展开放、对修改关闭。
简单工厂模式中每次业务改动都要增增加新的if-else就涉及到对已有代码的修改，容易出错，可读性也不好。

• 多个工厂类实现工厂接口，利用多态来创建不同的产品对象，从而避免了冗长的if-else判断。
• 为每一个子类创建其对应的工厂子类，只要我们实例化不同的工厂子类，调用创建方法得到的就是对应的子类对象。使用了面向对象的多态特性。

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

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

interface MaskFactory{
    Mask createMask();
}

class HighEndFactory implements MaskFactory{
    @Override
    public Mask createMask(){
        Mask mask=new HighEndMask();
        return mask;
    }
}

class LowEndFactory implements MaskFactory{
    @Override
    public Mask createMask(){
        Mask mask=new LowEndMask();
        return mask;
    }
}

public class FactoryMethodPattern {
    public static void main(String[] args) {
        MaskFactory lowendFactory=new LowEndFactory();
        MaskFactory highEndFactory=new HighEndFactory();
        Mask lowEndMask=lowendFactory.createMask();
        Mask highEndMask=highEndFactory.createMask();
        lowEndMask.showMask();
        highEndMask.showMask();
    }
}

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

3、抽象工厂模式

要是创建的子类越来越多，每一个子类都对应一个工厂类太繁琐了。
可以通过抽象工厂模式来解决

把产品子类进行分组，同组中的不同产品由同一个工厂子类的不同方法负责创建，从而减少了工厂子类的数量。

如图所示，每一个产品类都对应着一个工厂类，当产品数量很多的时候，工厂类的数量也会越老越多，搞得系统非常复杂。

如果要创建的产品很多，可以对产品进行分组。如上述例子中，可以分为高端组和低端组

interface factory{
    Mask createMask();
    ProtectiveSuit createSuit();
}

class HighEndFactory implements factory{
    @Override
    public Mask createMask() {
        Mask mask=new HighEndMask();
        return mask;
    }

    @Override
    public ProtectiveSuit createSuit() {
        ProtectiveSuit suit=new HighEndProtectiveSuit();
        return suit;
    }
}

class LowEndFactory implements factory{
    @Override
    public Mask createMask() {
        Mask mask=new LowEndMask();
        return mask;
    }

    @Override
    public ProtectiveSuit createSuit() {
        ProtectiveSuit suit=new LowEndProtectiveSuit();
        return suit;
    }
}

把产品类分组，组内不同产品对应于同一个工厂类的不同方法的设计模式就是抽象工厂模式。

4、三种工厂模式的异同点

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

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

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

5、Spring的工厂模式

待完善