Java设计模式-简单工厂模式
作者：互联网
一、简单工厂模式的概述
1. 定义：定义一个工厂类，它可以根据不同的参数返回不同的实例，被创建的实例通常具有相同的父类
以活字印刷术为例，不同活字的排列组合得到不同的文章，这些文章的活字都来源于同一套活字模板
2. 在简单工厂中被创建的实例方法通常是静态方法(Static Method)，因此简单工厂模式又被成为静态工厂方法(Statis Factory Method)
二、简单工厂模式的结构和实现
1. 结构
1）Factory(工厂):核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象
2）Product(抽象类产品)：工厂类所创建的所有对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象
3）ConcreteProduct(具体产品)：简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法(有关抽象类)
2. 实现
/**
* @author ***
* @title: Test2
* @projectName design-pattern
* @description TODO
* @date 2021/7/510:27
*/
abstract class Product {
public static void MethName() {
//公共方法的实现
}
public abstract void MethodDiff();
//声明抽象业务方法
}
class ConcreteProductA extends Product {
@Override
public void MethodDiff() {
//业务方法的实现
}
}
class ConcreteProductB extends Product {
@Override
public void MethodDiff() {
//业务方法的实现
}
}
class Factory {
public static Product GetProduct(String arg) {
Product product = null;
if (arg.equals("A")){
product = new ConcreteProductA();
//init
}else if (arg.equals("B")) {
product = new ConcreteProductB();
//init
} else {
//其他情况
}
return product;
}
}
class Program {
public static void main(String[] args) {
Product product;
product = Factory.GetProduct("A");//工厂类创建对象
Product.MethName();
product.MethodDiff();
}
}
三、简单工厂模式的优缺点和适用环境
1. 优点
1）工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
2）客户端无需知道所创建具体产品的类名，只需知道参数即可
3）也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。（这也是我在开始的披萨店里遇到没有的披萨的解决情况）
2. 缺点
1）工厂类集中了所有产品的创建逻辑，职责过重，一旦异常，整个系统将受影响
2）使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度
3）系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
4）简单工厂模式使用了static工厂方法，造成工厂角色无法形成基于继承的等级结构。
3. 适用环境
1）工厂类负责创建对的对象比较少，因为不会造成工厂方法中的业务逻辑过于复杂
2）客户端只知道传入工厂类的参数，对如何创建对象不关心
四、实际案例
利用简单工厂模式编写一款简单的计算器软件程序
我们在设计的时候最重要是将界面逻辑(main方法)和业务逻辑(普通方法)分开，降低代码之间的耦合度
业务逻辑：
/**
* @author ***
* @title: Operation
* @projectName design-pattern
* @description 运算抽象类
* @date 2021/7/510:49
*/
public abstract class Operation {
private double _numberA = 0;
private double _numberB = 0;
public double get_numberA() {
return _numberA;
}
public void set_numberA(double _numberA) {
this._numberA = _numberA;
}
public double get_numberB() {
return _numberB;
}
public void set_numberB(double _numberB) {
this._numberB = _numberB;
}
public abstract double getResult();
}
/**
* @author ***
* @title: OperationAdd
* @projectName design-pattern
* @description 加法类,继承运算类
* @date 2021/7/5 10:50
*/
public class OperationAdd extends Operation{
@Override
public double getResult() {
double result = 0;
return get_numberA() + get_numberB();
}
}
/**
* @author ***
* @title: OperationSub
* @projectName design-pattern
* @description 加减乘除类 -- 减法类，继承运算类
* @date 2021/7/5 10:51
*/
public class OperationSub extends Operation{
@Override
public double getResult() {
double result = 0;
return get_numberA() - get_numberB();
}
}
/**
* @author ***
* @title: OperationMul
* @projectName design-pattern
* @description 加减乘除类 -- 乘法类，继承运算类
* @date 2021/7/5 10:53
*/
public class OperationMul extends Operation{
@Override
public double getResult() {
double result = 0;
return get_numberA() * get_numberB();
}
}
/**
* @author ***
* @title: OperationDiv
* @projectName design-pattern
* @description 加减乘除类 -- 除法类,继承运算类
* @date 2021/7/5 10:54
*/
public class OperationDiv extends Operation{
@Override
public double getResult() {
double result = 0;
return get_numberA() / get_numberB();
}
}
/**
* @author ***
* @title: OperationFacotry
* @projectName design-pattern
* @description 简单运算工厂类
* @date 2021/7/5 10:57
*/
public class OperationFactory {
public static Operation createOperate(String operate){
Operation oper = null;
switch (operate)
{
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
case "/":
oper = new OperationDiv();
break;
}
return oper;
}
}
界面逻辑：
/**
* @author ***
* @title: ClassC
* @projectName design-pattern
* @description 客户端代码
* @date 2021/7/5 10:58
*/
public class ClassC {
public static void main(String[] args) {
Operation oper;
oper = OperationFactory.createOperate("-");
oper.set_numberA(1);
oper.set_numberB(2);
double result = oper.getResult();
System.out.println("结果是：" + result);
}
}
如此一来，那么我们需要增加各种复杂运算，比如平方根，立方根，自然对数，正弦余弦等，只需增加相应的运算子类就可以了。
标签：Java,numberA,double,class,工厂,numberB,设计模式,public 来源： https://www.cnblogs.com/mylqm/p/14971284.html