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();
}
}