工厂模式来啦

1 简单工厂模式

SimpleFactory

package factory.simplefactory;

public class SimpleFactory {

    public static Cloth getCloth(String type){

        if ("jok".equals(type)){
            return  new Jok();
        }else if ("dress".equals(type)){
            return  new Dress();
        }else {

            return null;
        }
    }

}

2 工厂方法模式

           定义：工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品

可以看到，上面右半部分是产品抽象和实现体系，左半部分是工厂抽象和实现体系，其中工厂体系依赖于产品体系，每一个工厂负责创造一种产品，这就省去了简单工厂中的elseif判断，又让客户端决定实例化一个特定的工厂去创建相应的产品

DressFactory

package factory.methodfactory;

public class DressFactory implements Factory{
    @Override
    public Cloth getCloth() {
        return new Dress();
    }
}

JokFactory

package factory.methodfactory;

public class JokFactory implements Factory{
    @Override
    public Cloth getCloth() {
        return new Jok();
    }
}

MethodFactoryTest

package factory.methodfactory;

import org.junit.Test;

public class MethodFactoryTest {
    @Test
    public void methodFactoryTest(){
        Cloth jok = new JokFactory().getCloth();
        Cloth dress = new DressFactory().getCloth();

        jok.name();
        dress.name();
    }
}

可以看到，我们使用可以随意的在具体的工厂和产品之间切换，并且不需要修改任何代码，就可以让原来的程序正常运行，这也是工厂方法模式对扩展开放的表现，另外工厂方法模式弥补了简单工厂模式不满足开闭原则的诟病，当我们需要增加产品时，只需要增加相应的产品和工厂类，而不需要修改现有的代码

小总结：
简单工厂模式不符合开闭原则，但是代码量少
工厂方法模式符合开闭原则，但是随着代码量会逐渐递增

3 抽象工厂模式

同一个产品族由由同一个抽象工厂创建·，但是其中包含不同的产品等级

类图

实例

AbstractFactory

package factory.abstractfactory;

public interface AbstractFactory {

   PhoneProduct getPhone();

   RoutorProduct getRouter();

}

HuaWeiFactory

package factory.abstractfactory;

import com.sun.security.sasl.util.AbstractSaslImpl;

public class HuaWeiFactory implements AbstractFactory{
    @Override
    public PhoneProduct getPhone() {
        return new HuaweiPhone();
    }

    @Override
    public RoutorProduct getRouter() {
        return new HuaweiRoutor();
    }
}

XiaomiFactory

public class XiaomiFactory implements AbstractFactory{
    @Override
    public PhoneProduct getPhone() {
        return new XiaomiPhone();
    }

    @Override
    public RoutorProduct getRouter() {
        return new XiaomiRoutor();
    }
}

AbstracteFactory

package factory.abstractfactory;

import org.junit.Test;

public class AbstracteFactory {

    @Test
    public void test(){
        System.out.println("++++++++++++++++小米工厂++++++++++++++++++++++");
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        PhoneProduct phone = xiaomiFactory.getPhone();
        RoutorProduct router = xiaomiFactory.getRouter();
        phone.action();
        router.action();

        System.out.println("+++++++++++++++华为工厂++++++++++++++++++++++++++++++");
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        PhoneProduct phone1 = huaWeiFactory.getPhone();
        RoutorProduct router1 = huaWeiFactory.getRouter();

        phone1.action();
        router1.action();


    }
}

小结：
1 抽象工厂模式：工厂中的抽象方法（产品等级）有多个，形成产品族，针对于产品族（一系列产品等级）
2 工厂方法模式：工厂中的抽象方法（产品等级）只有一个，针对于产品等级

总结

简单工厂模式本质上就是将if-else的叠加逻辑抽出来作为一个方法（工厂方法），又为了符合单一职责原则为这个工厂方法套上一个独立类（工厂类）。但是当叠加逻辑越来越多就会显得工厂方法很臃肿，且在新增逻辑时不符合开闭原则，所以就需要重构。
在重构的过程中需要解决简单工厂模式不遵循单一职责原则和开闭原则，则对工厂抽象和对结果（产品）抽象，由一个工厂负责创建一个产品，完美的解决了简单工厂存在的问题。
抽象工厂模式则是对工厂模式的升级迭代，工厂模式一个工厂只能创建一个产品，那么我有多个产品怎么办？
那就在增加工厂方法，多返回几个产品，但是返回的产品咱们得是统一的标准，所以得对同一个工厂内部的产品进行抽象。工厂模式的产品顶层只有一个抽象，抽象工厂模式则分割成多个顶层抽象。