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

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

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