1)基本原理
在这个模式中,工厂和产品类往往可以一一对应。即一个抽象工厂对应一个抽象产品,一个具体工厂对应一个具体产品,这个具体的工厂就负责生产对应的产品。该模式中包含的角色及其职责。
- 抽象工厂(Creator)角色:工厂方法模式的核心,与应用程序无关。任何在模式中创建对象的工厂必须实现这个接口。
- 具体工厂(Concerete Creator)角色:这个实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。
- 抽象产品(Product)角色:工厂方法模式所创建的对象的父类型,也就是产品对象的共同父类或共同拥有的接口。
- 具体产品(Concerte Product)角色:这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,他们之间往往一一对应。
2)优点
- 客户端不负责对象的创建,而且由专门的工厂类完成;
- 客户端只负责对象的调用,实现了创建和调用的分离,降低了客户端代码的难度;
- 若增加和减少产品子类,不需要修改工厂类,只增加产品子类和工厂子类,符合开闭原则。即使产品子类过多,不会导致工厂类的庞大,利于后期维护;
3)缺点
- 需要额外的代码编写,增加了工作量;
4)适用情况
- 所有的产品子类都有同一个父类(或接口),属于同一个产品系列产品子类比较多的,创建操作比较复杂;
抽象工厂(Creator)角色
public abstract class Calculator {
protected int num1;//运算数1
protected int num2;//运算数1
//生成有参无参构造方法,getset方法
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
public Calculator(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}
public Calculator() {}
/**
* 不同的运算,运算规则不同
* @return
*/
public abstract int calc();
}
具体工厂(Concerete Creator)角色
public class AddCalculator extends Calculator {
public AddCalculator(int num1, int num2) {
super(num1, num2);
}
public AddCalculator() {
}
public int calc() {
return num1+num2;
}
}
class SubtractCalculator extends Calculator {
public SubtractCalculator(int num1, int num2) {
super(num1, num2);
}
public SubtractCalculator() {
}
public int calc() {
return num1-num2;
}
}
class MultractCalculator extends Calculator {
public MultractCalculator(int num1, int num2) {
super(num1, num2);
}
public MultractCalculator() {
}
public int calc() {
if(num2!=0){
return num1*num2;
}else{
throw new RuntimeException("除数不能是0");
}
}
}
class DivideCalculator extends Calculator {
public DivideCalculator(int num1, int num2) {
super(num1, num2);
}
public DivideCalculator() {
}
public int calc() {
return num1/num2;
}
}
抽象产品(Product)角色
public interface CalcFactory {
/**
* 创建运算对象
* @return
*/
public Calculator getCalc();
}
具体产品(Concerte Product)角色
/**
* 添加工厂
*/
public class AddFactory implements CalcFactory{
public Calculator getCalc() {
return new AddCalculator();
}
}
/**
* 减去工厂
*/
class SubtractFactory implements CalcFactory{
public Calculator getCalc() {
return new SubtractCalculator();
}
}
/**
* 除法工厂
*/
class DivideFactory implements CalcFactory{
public Calculator getCalc() {
return new DivideCalculator();
}
}
/**
* 乘法工厂
*/
class MultractFactory implements CalcFactory{
public Calculator getCalc() {
return new MultractCalculator();
}
}
简单测试
public class Test {
//创建工厂
static CalcFactory factory = new AddFactory();
public static void main(String[] args) {
//从工厂中直接获取产品
Calculator calc = factory.getCalc();
calc.setNum1(1);
calc.setNum2(2);
//产品的调用
int calc1 = calc.calc();
System.out.println(calc1);
}
}
这里还有两种工厂模式大家有时间可以自己去拓展:
抽象工厂模式
构建者模式
三连就是对我最大的支持!!!