大话设计模式之简单工厂模式

该博客主要参考内容如下:

  1. 设计模式--简单工厂模式_w1992wishes的博客-CSDN博客
  2. 简单工厂模式_wangrcheng的博客-CSDN博客
  3. 设计模式之简单工厂模式_扫地僧-大白的博客-CSDN博客
  4. 大话设计模式

什么是简单工厂模式 

简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。说白了:就是创建对象的

简单工厂模式的组成

工厂类(Factory):简单工厂模式的核心,用来创建对象。

抽象产品类(Product):它一般是具体产品要继承的父类或者要实现的接口。

具体产品角色(ConcreteProduct):工厂类所创建的对象就是此角色的实例

如何使用简单工厂模式

假如有这样一个需求:写一个计算器 实现 + - x  /,你怎么做

第一段代码

/**
 * 一.问自己
 * 1.这样的程序,维护,扩展,复用性,灵活性 怎么样,是不是很差
 * 2.这样写相当于写死了,是不是,如果需求有变动,重新写一次?不可能,对不对
 * 二.怎么办,想一下
 * 1.首先想到 面向对象:封装,继承,多态,来提高:维护,扩展,复用性,灵活性
 * 2.利用封装,将逻辑层面与控制层面分开
 * 三.看第二层代码
 * 
 * */
public class Test {

	public static void main(String[] args) {
		
		  System.out.print("输入数字A:");
		  Scanner   scan =new Scanner(System.in);
		 String numberA = scan.nextLine();
		  System.out.println("输入运算符 +  -  x  /:"); 
		  Scanner  operator =new Scanner(System.in);
		  String operatorSelect = scan.nextLine();
		  System.out.println("输入数字B:"); 
		  Scanner  scanB =new Scanner(System.in); 
		  String numberB = scan.nextLine();
		  String result="";
		  double parseDouble =00d;
		  switch (operatorSelect) {
		case "+":
			parseDouble=Double.parseDouble(numberA)+Double.parseDouble(numberB);
			System.out.println(parseDouble);
			break;
		case "-":
			parseDouble=Double.parseDouble(numberA)-Double.parseDouble(numberB);
			System.out.println(parseDouble);
			break;
		case "x":
			parseDouble=Double.parseDouble(numberA)*Double.parseDouble(numberB);
			System.out.println(parseDouble);
			break;
		case "/":
			if (!numberB.equals("0")) {
				parseDouble=Double.parseDouble(numberA)/Double.parseDouble(numberB);
				System.out.println(parseDouble);
			}else {
				result="除数不能为0";
				System.out.println(result);
			}
			break;	
		default:
			System.out.println("运算符输入有误");
			break;
		}
	}
}

 第二部分

public class Test1 {
/***
 * 一.看了第二层代码,问自己
 * 1.这样实现了我们说的问题了吗,她只是把逻辑层面封装起来了,是不是
 * 2.如果我们要加一个开根运算呢,在逻辑层面加一个case 语句,是这样吗,如果是这样,就不要看往下看了
 * 3.增加一个运算类型,万一你增加case语句,修改了其他其他case语句的内容,其他case 语句是别人写的,你改了,会不会揍你,
 * 别说你不会,小心驶得万年船
 * 二。怎么办,想一下
 * 1.既然不能在一个类里,这样容易影响其他运算类型,那就分开来,每种方法都写一个类,这样就不会影响了吧
 * 2.看第三层代码
 * 
 * */
public static void main(String[] args) {
//	第一个数字
	 System.out.print("输入数字A:");
	  Scanner   scan =new Scanner(System.in);
	 String numberA = scan.nextLine();
	 double numberAa = Double.parseDouble(numberA);
//	 运算符
	  System.out.println("输入运算符 +  -  x  /:"); 
	  Scanner  operator =new Scanner(System.in);
	  String operatorSelect = scan.nextLine();
//	  第二个数字
	  System.out.println("输入数字B:"); 
	  Scanner  scanB =new Scanner(System.in); 
	  String numberB = scan.nextLine();
	  double numberBb = Double.parseDouble(numberB);
//	  调用封装的方法
	  Operation.getResult(numberAa, operatorSelect, numberBb);
}
}
public class Operation {

	public static void getResult(Double numberAa,String opera,Double numberBb) {
		String errorResult="除数不能为0";
		  double result =00d;
		  switch (opera) {
		case "+":
			result=numberAa+numberBb;
			System.out.println(result);
			break;
		case "-":
			result=numberAa-numberBb;
			System.out.println(result);
			break;
		case "x":
			result=numberAa*numberBb;
			System.out.println(result);
			break;
		case "/":
			
			if (numberBb!=0) {
				result=numberAa/numberBb;
				System.out.println(result);
			}else {
				System.out.println(errorResult);
			}
			break;
		default:
			System.out.println("运算符输入有误");
			break;
		}
		} 
}

第三部分

/**
 * 基类  加 减 成  除 的共性
 * */
public class OperationA {
  private Double numberA;
  private Double numberB;
public Double getNumberA() {
	return numberA;
}
public void setNumberA(Double numberA) {
	this.numberA = numberA;
}
public Double getNumberB() {
	return numberB;
}
public void setNumberB(Double numberB) {
	this.numberB = numberB;
}
  public double result(Double numberA,Double numberB){
	  double result=0;
	return result;
  }
}

加法

public class Add extends OperationA{
	 public double result(Double numberA,Double numberB){
		  double result=0;
		  result=numberA+numberB;
		  System.out.println(result);
		return result;
	  }
}

减法

public class Sub extends OperationA{
	public double result(Double numberA,Double numberB){
		  double result=0;
		  result=numberA-numberB;
		  System.out.println(result);
		return result;
	  }
}

乘法

public class Mul extends OperationA{
	public double result(Double numberA,Double numberB){
		  double result=0;
		  result=numberA*numberB;
		  System.out.println(result);
		return result;
	  }
}

除法

public class Div extends OperationA{
	public double result(Double numberA,Double numberB){
		  double result=0;
		  if (numberB!=0) {
			  result=numberA/numberB;
			  System.out.println(result);
		}else {
			System.out.println("除数不能为0");
		}
		  
		return result;
	  }
}

工厂

public class OperationFactory {
	
  public  static OperationA getOperation(String opera) {
	  
	  OperationA operationA=null;
	  
	  switch (opera) {
	case "+":
		operationA=new Add();
		break;
	case "-":
		operationA=new Sub();
		break;
	case "X":
		operationA=new Mul();
		break;
	case "/":
		operationA=new Div();
		break;
	case "%":
		operationA=new yushu();
		break;	
	default:
		System.out.println("运算符输入有误");
	}
	return operationA;
	  
  }
}

调用

public class Test3 {
/**
 * 一。看第三层代码有,问自己
 * 1.这层代码都干嘛了,有没有实现:维护,扩展,复用性,灵活性
 * 2.分析:2.1每种运算都有自己独立的类,需要那种用那种,具有灵活性,复用性也强
 *         2.2 扩展:当需要一个其他方法时(求余数),增加对应的类,并且在工厂里添加该类即可
 *         2.3:维护:如果要修改加法,只需要在add 类做修改,而不是一个 什么都有的类里修改,不会修改其他运算的核心算法,便于维护
 *   二,这就是简单工厂模式      
 * */
	
public static void main(String[] args) {
//1.	+ - x /   的基类
	OperationA operation=null;
//2.	根据不同的运算获得不同的对象(工厂模式)
	operation = OperationFactory.getOperation("+");
	double result = operation.result(3.1, 2.2);
	System.out.println(result);
}
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值