首页 > 其他分享> > 设计模式的魅力一

设计模式的魅力一

2021-05-14 10:31:07 作者：互联网

设计模式之简单工厂模式

第一次学习设计模式的一些感想
- 何为简单工厂模式
做一个简单的计算器控制台吧

第一次学习设计模式的一些感想

在这里插入图片描述

目前在看《大话设计模式》这本书，便宜，又易懂。
步骤拆分很到位
就是发现确实能提升自己代码的逻辑性，能够感受到设计模式带来的便利，要去理解为什么要这么做，这么做的好处是什么。

何为简单工厂模式

它使用了面向对象的三大特性
1.封装:业务逻辑和界面逻辑的分离，才能使其易于扩展和维护。这样能让它们之间的耦合度降低
2.继承和多态:能使其做到很灵活的扩展和修改，以及代码的复用
简单工厂模式就是指，到底要实例化谁，以后会不会增加一个功能，增加一个实例化的对象需要用一个类单独来做这个创造实例的过程

做一个简单的计算器控制台吧

一.刚出来的我

刚工作出来的，当然我也不例外，总是喜欢把代码写在一堆，犹如计算机模式一样去写代码。

public static void main(String[] args) {
		// 模拟两个double
		double A = 1.05;
		double B = 2.00;
		// 模拟运算符
		String operation = "+";
		double result = 0;
		if (operation.equals("+")) {
			result = strNumA + strNumB;
		}
		if (operation.equals("-")) {
			result = strNumA - strNumB;
		}
		if (operation.equals("*")) {
			result = strNumA * strNumB;
		}
		if (operation.equals("/")) {
			result = strNumA / strNumB;
		}
		System.out.println(result + "");
	}

emmm,一个简单又有bug的简易计算器就做好了

二.干了一段时间的我

干了一段时间后，发现自己代码及其不规范
于是有了下面好了一点的代码

public static void main(String[] args) {
		// 模拟两个double
		double strNumA = 1.05;
		double strNumB = 0;
		// 模拟运算符
		String operation = "/";
		double result = 0;
		switch (operation) {
		case "+":
			result = strNumA + strNumB;
			break;
		case "-":
			result = strNumA - strNumB;
			break;
		case "*":
			result = strNumA * strNumB;
			break;
		case "/":
			if (strNumB == 0) {
				try {
					throw new Exception("分母不能为0！");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			result = strNumA / strNumB;
			break;
		}

		System.out.println(result + "");
	}

三.被屌了一段时间后

被叼了很多次后，才知道要代码分离，方便维护，和扩展。使代码可以复用，而不是复制
也是一种面向对象的思想。
于是：

//业务类
public class Operation {

	public double result(double strNumA, double strNumB, String operat) {
		double result = 0;
		switch (operat) {
		case "+":
			result = strNumA + strNumB;
			break;
		case "-":
			result = strNumA - strNumB;
			break;
		case "*":
			result = strNumA * strNumB;
			break;
		case "/":
			if (strNumB == 0) {
				try {
					throw new Exception("分母不能为0！");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			result = strNumA / strNumB;
			break;
		}
		return result;
	}
}

//界面类
public static void main(String[] args) {
		// 模拟两个double
		double strNumA = 1.05;
		double strNumB = 0.05;
		// 模拟运算符
		String operat = "/";

		double result = new Operation().result(strNumA, strNumB, operat);

		System.out.println(result + "");
	}

四.经过N多次修改自己的代码

无论是需求上的更改还是自己业务上的逻辑没有理清楚就开始码。都发现自己写的爱码，难维护，有点像叛逆期的孩子。
而且上面的爱码并不能很灵活的扩展和修改。
当你想修改或者新增某一个运算时。会很容易修改到别的运算规律。
风险太大了
尝试着把多态和继承也弄进去。使代码达到松耦合的情况。
于是我们可以把业务类里的各种运算规则分离开

//运算类是一个大概念的类
public class Computing {
	private double strNumA;
	private double strNumB;
	public double getStrNumA() {
		return strNumA;
	}
	public void setStrNumA(double strNumA) {
		this.strNumA = strNumA;
	}
	public double getStrNumB() {
		return strNumB;
	}
	public void setStrNumB(double strNumB) {
		this.strNumB = strNumB;
	}
	public double getResult() {
		double result = 0;
		return result ;
	}
}
//加减乘除类，需要去继承运算类，并重写运算类的getResult虚方法
//加法类
public class OperationADD extends Computing {
	public double getResult() {
		double result = 0;
		result = getStrNumA() + getStrNumB();
		return result;
	}
}
//减法类
public class OperationSUB extends Computing {
	public double getResult() {
		double result = 0;
		result = getStrNumA() - getStrNumB();
		return result;
	}
}
//乘法类
public class OperationMUL extends Computing {
	public double getResult() {
		double result = 0;
		result = getStrNumA() * getStrNumB();
		return result;
	}
}
//除法类
public class OperationDIV extends Computing {
	public double getResult() {
		if (getStrNumB() == 0) {
			try {
				throw new Exception("分母不能为零！");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		double result = 0;
		result = getStrNumA() / getStrNumB();
		return result;
	}
}

五.简单工厂模式

继承运算类，去重写里面的运算方法，之后再修改某个运算规则就不会动到其他的代码，但如何让计算机知道我需要的是哪一个运算规则呢？
也就是如何去实例化对象的问题
本次内容的设计模式就可以做到帮你去创建实例，你只需要传入运算符，就会自动给你想要的对象，这就是工厂

//运算工厂
public class OperationFactory {
	public Computing createComputing(String operat) {
		Computing com = null;
		switch (operat) {
		case "+":
			com = new OperationADD();
			break;
		case "-":
			com = new OperationSUB();
			break;
		case "*":
			com = new OperationMUL();
			break;
		case "/":
			com = new OperationDIV();
			break;
		}
		return com;
	}
}

通过多态，返回父类的方式就实现了计算器的结果

//界面代码
public static void main(String[] args) {
		OperationFactory operationFactory = 
		new OperationFactory();
		//向工厂要自己想要的运算对象
		Computing computing = 
		operationFactory.createComputing("+");
		computing.setStrNumA(4.50);
		computing.setStrNumB(5.65);
		double retuResult = computing.getResult();
		System.out.println(retuResult + "");
	}

后续你想要去增加一种运算，需要创建类去继承运算类。并在工厂注入此运算的创建规则，就可以使用了

直到不久前才理解到，编程学无止境。

谢谢大家的观看

在这里插入图片描述

标签：strNumA,double,break,result,魅力,strNumB,设计模式,public
来源： https://blog.csdn.net/java_death/article/details/116779571