设计模式 —— 简单工厂→工厂模式

Yu_Nan___

于 2020-03-31 21:21:00 发布

阅读量983

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/Yu_Nan___/article/details/105232017

版权

设计模式专栏收录该内容

23 篇文章 0 订阅

订阅专栏

例：设计程序实现加减乘除，并容易扩展其他运算方式
工厂具有逻辑判断功能，一个工厂实现不同类的创建

方法一：简单工厂模式

在这里插入图片描述工厂代码：

class operationfactory
{
	public static operation creationoperation(String operation)
	{
		operation oper=null;
		switch(operation)
		{
		  case "+":oper=new add1();break;
		  case "-":oper=new subtract();break;
		  case "*":oper=new ride();break;
		  case "/":oper=new divided();break;
		}
		return oper;
	}
}

源代码：

package org.yunan.design;

import java.util.Scanner;

public class simplefactory {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Scanner sc=new Scanner(System.in);
      operation oper;
      System.out.println("输入操作符");
      oper= operationfactory.creationoperation(sc.next());
      System.out.println("输入第一个操作数");
      oper.num1=sc.nextDouble();
      System.out.println("输入第二个操作数");
      oper.num2=sc.nextDouble();
      System.out.println( "运算结果:"+oper.Getresult());
      
      
	}

}
abstract class operation
{
	public double num1,num2;
	public abstract double Getresult();
}

class add1 extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1+num2;
	}
}
class subtract extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1-num2;
	}
}
class ride extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1*num2;
	}
}
class divided extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1/num2;
	}
}
class operationfactory
{
	public static operation creationoperation(String operation)
	{
		operation oper=null;
		switch(operation)
		{
		  case "+":oper=new add1();break;
		  case "-":oper=new subtract();break;
		  case "*":oper=new ride();break;
		  case "/":oper=new divided();break;
		}
		return oper;
	}
}

优点

（1）简单工厂包含必要的判断逻辑，简单工厂实现了对象的创建和使用的分离。
（2）客户端无需知道所创建的具体产品类的类名，只需要具体产品类对应的参数即可！
（3）在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性
缺点

（1）工厂类的职责过重，从类图中可以看出简单工厂中包含加减乘除的逻辑判断语句，它一旦有问题，整个系统都要出问题
（2）在添加新的类的时候，例如我添加了开根号运算，那么系统中的简单工厂类就要修改，违反了开放——封闭原则！这样及其不利于系统的扩展和维护！
（3）简单工厂的静态方法，使得工厂角色无法形成基于继承的等级结构！

改进：对工厂类实现分类实现单一职责原则，开闭原则，防止源代码的过度曝光；每一种算法都对应一个工厂

方法二：工厂模式

在这里插入图片描述工厂类代码：

interface operationfactory
{
	operation creationoperation();
}
class add1factory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new add1();
	}
}
class subtractfactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new subtract() ;
	}
	
}
class ridefactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new ride();
	}
	
}
class dividedfactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new divided();
	}
	
}

源代码：

package org.yunan.design;

import java.util.Scanner;

public class factory {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Scanner sc=new Scanner(System.in);
      operationfactory operfactory=null;
      System.out.println("输入操作符");
      switch(sc.next())
		{
		  case "+":operfactory=new add1factory();break;
		  case "-":operfactory=new subtractfactory();break;
		  case "*":operfactory=new ridefactory();break;
		  case "/":operfactory=new dividedfactory();break;
		}
      operation oper=operfactory.creationoperation();
      System.out.println("输入第一个操作数");
      oper.num1=sc.nextDouble();
      System.out.println("输入第二个操作数");
      oper.num2=sc.nextDouble();
      System.out.println( "运算结果:"+oper.Getresult());
      
      
	}

}
abstract class operation
{
	public double num1,num2;
	public abstract double Getresult();
}

class add1 extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1+num2;
	}
}
class subtract extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1-num2;
	}
}
class ride extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1*num2;
	}
}
class divided extends operation
{

	@Override
	public double Getresult() {
		// TODO Auto-generated method stub
		return num1/num2;
	}
}
interface operationfactory
{
	operation creationoperation();
}
class add1factory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new add1();
	}
}
class subtractfactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new subtract() ;
	}
	
}
class ridefactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new ride();
	}
	
}
class dividedfactory implements operationfactory
{

	@Override
	public operation creationoperation() {
		// TODO Auto-generated method stub
		return new divided();
	}
	
}

优点：

（1）工厂方法用来创建客户所需要的产品，同时隐藏了哪种具体产品类将被实例化的细节，用户只需要要关注工厂，不需要关注创建的细节！从客户端代码就可以看出！只知道对应的工厂就好！
(2)在增加修改新的运算类的时候不用修改代码，只需要增加对应的工厂就好，完全符合开放——封闭性原则！
（3）创建对象的细节完全封装在具体的工厂内部，而且有了抽象的工厂类，所有的具体工厂都继承了自己的父类！完美的体现了多态性！
缺点：
（1）在增加新的产品（对应UML图的算法）时，也必须增加新的工厂类，会带来额外的开销
（2）抽象层的加入使得理解程度加大

以上部分摘取自朱红梅老师2020年5月的课件。

Yu_Nan___

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式 —— 简单工厂→工厂模式

例：设计程序实现加减乘除，并容易扩展其他运算方式工厂具有逻辑判断功能，一个工厂实现不同类的创建方法一：简单工厂模式package org.yunan.design;import java.util.Scanner;public class simplefactory { public static void main(String[] args) { // TODO Auto...
复制链接

扫一扫