简单工厂模式-CSDN博客

本文链接：https://blog.csdn.net/qq_45102119/article/details/126931116

前言：
设计模式并不是一种语言，而是在Java的大环境下，基于开发经验的一种代码格式。每一种设计模式都不是凭空出现的，每一种设计模式的出现，都是在开发中总结梳理出的经验，为了满足客户需求，且为了能够提高性能，增强代码灵活性，提高复用性，解耦，从大量的代码经验中提取而来的。
可以说每一种设计模式都是智慧的结晶，而且都离不开开发者们多年的代码积累。
那么就意味着要学习设计模式，要拥有大量的代码量和开发经验。

设计模式首先要明白一点：就是设计模式是基于面向对象语言的。
那就要了解面向对象的特点：封装，继承，多态、
封装的来源是：
如果我们在开发中，为了实现代码的安全性，不允许用户查看具体实现方法，只向用户提供使用权。也就是每个对象都包含他能进行操作所需要的所有信息，这个特性称之为封装。因此对象不用依赖其他对象就能完成自己的操作。
这样属性和方法都包装在类中，通过类的实例来实现。

封装的优点：
1，良好的封装可以减少耦合。
2，类内部的实现可以自由修改。
3，对外暴露接口。
继承的来源是：
大量的重复代码导致代码冗杂，为了增强代码的复用性我们提出了继承。
简单的描述就是：
对象的继承是一个IS-A关系，继承者可以说是父类的特殊化，因为除了拥有父类的特性以外，还有有自己的特性，比如猫是一个哺乳动物。其中猫既有哺乳动物的特征，又有自己特有的行为。
子类继承了父类那么就拥有了父类非Private的属性和行为。
子类可以拥有自己特有的属性和行为。（即为声明自己新的属性和方法）
子类还可以以自己的方式实现父类的方法（即为重写）
protected类的意思就是对自己的子类公开。其他类无法访问。
多态的来源是：
在程序设计之初，程序设计者只要给出轮廓，具体算法不用给出。
让子类实现的时候再给出具体算法。
多态常见的有上转型对象，接口回调。
多态实际上是比较抽象的。子类父类的方式出现。
但是实际工作时按照自己的方式来做。
而且子类以父类的方式出现时，不能使用自己的特有属性和方法了。
接触过上转型对象，接口回调会了解到。
开发中，为了开发效率，设计设给父类设置抽象或者说虚方法，
他们在JAVA中是没有方法体的·，子类通过extend重写父类。
将父类的抽象方法实现为自己的具体方法时，这被叫做方法重写。
最通俗的说法就是不同的子类可以执行相同的父类动作，但是实现方式时自己的。
例子：动物时狗的父类：
Animal animal=new Dog();
狗的引用被赋值给了animal.
也就是说继承链中，无论对象是否被转换为其父类，实现方法永远都是继承链最末端的方法会被实现。

> 简单的了解了面向对象之后我们开始学习第一个设计模式：简单工厂模式。

设计模式涉及到面向对象的特性，还有解耦等。
设计模式要求我们让代码更灵活，容易修改，便于复用。
简单工厂模式就是将容易变化的用户需求抽象起来。
用继承的方式实现每一个具体的需求，
这样做的好处就是，每一个操作都是一个独立的子类。
想要修改时单独拿出来就行，不用再去把全部的类都拿出来。
让代码更加灵活。
操作抽象出来了，那么我们怎样来控制实例化那一个，将来有了新的需求怎么办呢？
那我们就用一个单独的类来实现创建实例的过程。
这就是工厂。
以一个计算器为例子：
我们吧对两个数的操作封装为Operation父类：

public class Operation {
	private int num1=0;
	private int num2=0;
	
	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 double GetResult(){
		double result=0;
		return result;
	}
	
}

把我们的需求用继承的方式，给出他们的子类：比如加减操作：+，-

 public class OperationAdd extends Operation {
	@Override
	public double GetResult() {
		double result=0;
		result=getNum1()+getNum2();
		return result;
	}
}

public class OpeartionSub extends Operation{
	@Override
	public double GetResult() {
		double result=0;
		result=getNum1()-getNum2();
		return result;
	}
}

可以看到子类通过继承父类实现了具体的算法，
每一个GetResult里面都是自己特有的算法。
那我们怎么来确定要使用那一个子类来实例化，
将来新的需求产生了怎么办？
这就是我们工厂类的诞生：

 public class OperationFactory {
	public static Operation setOperation(String opeartion){
		Operation oper=null;
		switch (opeartion){
			case "+":
				oper=new OperationAdd();
				break;
			case "-":
				oper=new OpeartionSub();
				break;
			case "*":
				oper=new OpeartionSub();
				break;
			case "/":
				oper=new OperationDiv();
				break;
			default:
				System.out.println("输入有问题");
		}
		return oper;
	}
}

那我们实现了上面提出的要求了吗？我们看到setOperation（）方法用多态的方式，我们只要用户给出哪个需求，那我们就实例化哪一个。
可以看到我们已经实现了工厂的要求。那我们要是想要添加：*，/方法呢？那我们就添加相应的子类就可以了。
当然，还要在工厂中添加上新的实例化方法就行了。

public class OperationMul extends Operation{
	@Override
	public double GetResult() {
		double result=0;
		result=getNum1()*getNum2();
		return result;
	}
}
public class OperationDiv extends Operation{
	@Override
	public double GetResult() {
		double result=0;
		try{
			result=getNum1()/getNum2();
		}catch (Exception e){
			System.out.println("出现异常");
		}finally {
			return result;
		}
	}
}	
			case "*":
				oper=new OpeartionSub();
				break;
			case "/":
				oper=new OperationDiv();
				break;