工厂模式

2.5工厂模式

使用者可以直接消费产品而不需要知道其生产的细节

组成角色：

• 抽象产品（描述产品的公共接口，如水桶具备盛水功能）
• 具体产品（公共接口的实现类，如圆桶，方桶）
• 工厂（根据传入的参数生产不同的产品）

2.5.1简单工厂模式

public interface Api {
    //定义一个接口方法
    void operation();
}

public class ApiImplA implements Api {

    @Override
    public void operation() {
        System.out.println("this is A");
    }
}
public class ApiImplB implements Api {
    @Override
    public void operation() {
        System.out.println("this is B");
    }
}

/**
 * @author pandas
 * @ClassName SimpleFactoryMode
 * @Description 简单工厂的核心思想是选择实现
 * @create 2020/1/7 8:01
 */
public class SimpleFactoryMode {
    public static Api createApiStatic(int type){
        if (type==1){
            return new ApiImplA();
        }else if (type==2){
            return new ApiImplB();
        }
        return null;
    }
    public static void main(String[] args) {
        SimpleFactoryMode.createApiStatic(1).operation();
        SimpleFactoryMode.createApiStatic(2).operation();
    }

}

优点：

• 将创建实例的操作与使用实例的操作分开，使用者不需要关系怎么实现，实现解耦；
• 工厂模式更加专注，符合面向接口编程的原则

缺点：

• 工厂类集中了所有实例的创建逻辑，如果这个工厂出现问题，整个系统都会受到影响
• 违背ocp原则，一旦添加新产品就不得不修改工厂生产逻辑
• 简单工厂使用静态工厂方法，使得静态方法不能被继承和重写，造成工厂角色无法形成基于继承的等级结构

应用场景：

• 客户只需要传入工厂类参数的实现
• 工厂产品较少

2.5.2工厂方法模式

又称工厂模式，多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类负责具体实现。

主要作用，将简单工厂中，类的实现从工厂父类中延迟到子类实现，由子类决定创建哪个类。

//抽象工厂父类
public abstract class ApiFactory {
    //定义抽象方法，让子类实现
    public abstract Api manuFactory();
    //.....其他的公用属性与功能
}
//抽象工厂子类，具体实现哪个类
public class ApiFactoryA extends ApiFactory {
    @Override
    public Api manuFactory() {
        return new ApiImplA();
    }
}
public class ApiImplB implements Api {
    @Override
    public void operation() {
        System.out.println("this is B");
    }
}

public class FactoryMethodMode {

    public static void main(String[] args) {
        //工厂A
        ApiFactoryA apiFactoryA = new ApiFactoryA();
        apiFactoryA.manuFactory().operation();
        //工厂B
        ApiFactoryB apiFactoryB = new ApiFactoryB();
        apiFactoryB.manuFactory().operation();
    }
}

优点：

• 符合ocp原则，需要增加产品时，只需要添加相应的工厂子类与产品类

  简单工厂需要更改工厂逻辑

• 符合单一职责原则，每个工厂只负责创建对应的产品

• 不使用静态工厂方法，形成基于继承的等级结构

缺点：

• 每增加一种产品，就增加了类方法

2.5.3抽象工厂模式

• 定义了一个interface用于创建相关或依赖关系的对象簇，而无需指明具体的类

• 将简单工厂模式与工厂方法模式进行整合，进一步抽象

• 增加新产品只需要增加具体的产品类，工厂类不要改变

//将工厂抽象
public abstract class AbstractApiFactory {
    public abstract <T extends Api> T operation(Class<T> tClass);
}
//抽象工厂实现类，通过反射机制实现
public class AbstractApiFactoryImpl extends AbstractApiFactory{
    @Override
    public <T extends Api> T operation(Class<T> tClass) {
        String classname=tClass.getName();
        Api api=null;
        try {
            api= (Api) Class.forName(classname).newInstance();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) api;
    }

    public static void main(String[] args) {
        AbstractApiFactoryImpl abstractApiFactory = new AbstractApiFactoryImpl();
        ApiImplA apiImplA = abstractApiFactory.operation(ApiImplA.class);
        ApiImplB apiImplB = abstractApiFactory.operation(ApiImplB.class);
        apiImplA.operation();
        apiImplB.operation();

    }
}