工厂模式从字面可以理解为批量生产的意思,也就是说一个类的创建可以进行批量的生产,那么对于批量生产类其实有一个公共的特点,那就是肯定有一个模型,不然不可能批量,从这种思想我们可以想到在java面向对象中,该思想不谋为何,就是事物的抽象,通过抽象的事物可以创建我们现实生活中的具体事物。
因此对于工厂模型我们可以这么归类:
1: 要想实现工厂模式,必须要有一个模型,这个模型就是事物的抽象,拥有对象的基本特征。
2:要想生成多个对象的特征,必须需要多个类去继承该模型的基本特征。
【JAVA中哪些地方用到了工厂模式】
1:在spring中。容器创建bean的实例
2:在运用动态代理中也存在
【具体使用】
【场景】自定义计算器,接收键盘数字可以进行加减乘除等基本的数字运算
首先建立模型,也就是事物的抽象类,在改类中包含基本的事物特征
package com.example.springtest.other.pojo;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class Operation {
//返回结果
double result = 0;
//除数
private int param1 ;
//被除数
private int param2 ;
public Operation() {
}
public Operation(int param1, int param2) {
this.param1 = param1;
this.param2 = param2;
}
public int getParam1() {
return param1;
}
public void setParam1(int param1) {
this.param1 = param1;
}
public int getParam2() {
return param2;
}
public void setParam2(int param2) {
this.param2 = param2;
}
/**
* 结果
* @return
*/
public double getResult() {
return result;
}
}
建立加减乘除四个四类,这四个子类都继承Operation基本类,并重写计算结果的方法,即getResult()方法
1:
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class AddOp extends Operation {
private double result = 0;
/**
* 加法类,重写getResult()方法,重写的内容可以是业务逻辑,比如判断参数是否合法等
* @return
*/
@Override
public double getResult() {
result = getParam1()+getParam2();
return result;
}
}
:2:
package com.example.springtest.other.pojo;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class ReduceOp extends Operation{
private double result;
/**
* 减法
* 结果
* @return
*/
@Override
public double getResult() {
result = getParam1() - getParam2();
return result;
}
}
3
package com.example.springtest.other.pojo;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class RideOp extends Operation{
private double result;
/**
* 乘法
* 结果
* @return
*/
@Override
public double getResult() {
result = getParam1() * getParam2();
return result;
}
}
4:
package com.example.springtest.other.pojo;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class DeleteOp extends Operation{
private double result;
/**除法
* 结果
* @return
*/
@Override
public double getResult() {
result = getParam1() / getParam2();
return result;
}
}
子类写好之后,可以思考,java的三大特性 封装 继承 多态 在这样的业务中刚好可以使用多太,因为一个父类下面有四个子类,在我们业务中,不管是要进行加还是减,最终都是使用Operation的一个子类,建立一个方法,可以产生不同的子类,这个类其实就是工厂类
package com.example.springtest.other.service;
import com.example.springtest.other.pojo.*;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class OperationFactory {
/**
* 可以通过判断符号来生成不同的子类,这里用到的就是多态
* @param str
* @return
*/
public static Operation getOperation(String str) {
Operation operation = null;
switch (str) {
case "+":
operation = new AddOp();
break;
case "-":
operation = new ReduceOp();
break;
case "*":
operation = new RideOp();
break;
case "/":
operation = new DeleteOp();
break;
}
return operation;
}
}
测试结果:
package com.example.springtest.other.test;
import com.example.springtest.other.pojo.Operation;
import com.example.springtest.other.service.OperationFactory;
import org.junit.jupiter.api.Test;
/**
* ***GOOD LUCK****
*
* @Author : Wukn
* @Date : 2018/6/
*/
public class SDemo {
@Test
public void test1() {
Operation operation = null;
operation = OperationFactory.getOperation( "+" );
operation.setParam1( 1 );
operation.setParam2( 2 );
double result = operation.getResult();
System.out.println(result);
}
}
以上就是简单工厂的设计思想,值得我们去思考。
结构图