简单工厂模式、工厂方法模式、抽象工厂模式

一、简单工厂模式

常规设计：多个客户端对应一个创建产品类。一旦新增产品，每个客户端都需要修改，耦合性太高。简
单工厂模式：客户与创建产品中添加一个工厂，创建对象都在工厂中，一旦新增产品，只需要修改工厂

二、工厂方法模式

抽象产品接口
具体产品类（实现抽象产品接口方法）
抽象工厂接口
具体工厂类（实现抽象产品接口及创建具体产品类）
中间件：聚合抽象工厂接口，接口调用具体工厂类方法创建具体产品

//抽象产品类
public interface IAbstractProduct {
    void typeProduct();
}
//具体产品1
public class SpecificProductOne implements IAbstractProduct{
    @Override
    public void typeProduct() {
        System.out.println("I am SpecificProductOne");
    }
}
//具体产品2
public class SpecificProductTwo implements IAbstractProduct{
    @Override
    public void typeProduct() {
        System.out.println("I am SpecificProductTwo");
    }
}

//抽象工厂类
public interface IAbstractFactory {
    IAbstractProduct createSpecificProduct();
}
//具体产品1的具体工厂
public class SpecificProductOneFactory implements IAbstractFactory{
    @Override
    public IAbstractProduct createSpecificProduct() {
        return new SpecificProductOne();
    }
}
//具体产品2的具体工厂
public class SpecificProductTwoFactory implements IAbstractFactory{
    @Override
    public IAbstractProduct createSpecificProduct() {
        return new SpecificProductTwo();
    }
}

//中间件
public class ProductFactory {
    private IAbstractProduct product;
    //聚合抽象产品类
    public ProductFactory(IAbstractProduct product) {
        this.product = product;
    }
    public void getTypeProduct(){
        product.typeProduct();
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        //抽象工厂
        IAbstractFactory iAbstractFactory = new SpecificProductOneFactory();
        //抽象工厂调用创建具体产品
        IAbstractProduct specificProductOne = iAbstractFactory.createSpecificProduct();
        //中间件聚合具体产品(抽象产品类)
        ProductFactory productFactory = new ProductFactory(specificProductOne);
        //抽象产品类调用方法
        productFactory.getTypeProduct();
    }
}

若添加新产品，则新增具体产品3类和具体工厂3类就可以，将客户端new 产品1工厂替换成产品3工厂就可以，符合开闭原则。

三、抽象工厂模式

//手机产品接口
interface IPhoneProduct{
    //开机
    void start();
    //关机
    void shutdown();
}
//路由器产品接口
interface IRouterProduct{
    //开机
    void start();
    //关机
    void shutdown();
}

//华为手机实现类
class HuaweiPhone implements IPhoneProduct{

    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }
}
//华为路由器实现类
class HuaweiRouter implements IRouterProduct{

    @Override
    public void start() {
        System.out.println("开启华为路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }
}
//小米手机实现类
class XiaomiPhone implements IPhoneProduct{

    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }
}
//小米路由器实现类
class XiaomiRouter implements IRouterProduct{

    @Override
    public void start() {
        System.out.println("开启小米路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }
}

//工厂接口类
interface IProductFactory{
    //生产手机
    IPhoneProduct phoneProduct();
    //生产路由器
    IRouterProduct routerProduct();
}

//华为工厂实现类
class HuaweiFactory implements IProductFactory{

    @Override
    public IPhoneProduct phoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct routerProduct() {
        return new HuaweiRouter();
    }
}
//小米工厂实现类
class XiaomiFactory implements IProductFactory{

    @Override
    public IPhoneProduct phoneProduct() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterProduct routerProduct() {
        return new XiaomiRouter();
    }
}


public class ClientAbstractFactory {
    public static void main(String[] args) {

        //华为工厂
        IProductFactory factory = new HuaweiFactory();
        IPhoneProduct product = factory.phoneProduct();
        IRouterProduct router = factory.routerProduct();
        product.start();
        product.shutdown();
        router.start();
        router.shutdown();

    }
}