设计模式第五次作业---简单工厂模式、工厂方法模式、抽象工厂模式

最新推荐文章于 2023-07-17 09:51:34 发布
最新推荐文章于 2023-07-17 09:51:34 发布
阅读量299 收藏 4
点赞数 1
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43470016/article/details/105234172
版权

简单工厂模式

工厂类角色Creator:工厂类在客户端的直接控制下( Create方法)创建产品对象。
抽象产品角色Product:定义简单工厂创建的对象的父类或它们共同拥有的接口。可以是一个类、抽象类或接口。
具体产品角色ConcreteProduct:定义工厂具体加工出的对象。

简单工厂模式——实现简单运算

代码一

import java.util.Scanner;

public class main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strA = sc.nextLine();
		System.out.println("请输入运算符号（+、—、*、/）：");
		String stroper = sc.nextLine();
		System.out.println("请输入数字B：");
		String strB = sc.nextLine();
		Operation oper = OperationFactory.createOperation(stroper.charAt(0));
		oper.setNumberA(Double.parseDouble(strA));
		oper.setNumberB(Double.parseDouble(strB));
		System.out.println("结果是：" + oper.getResult());

	}
}

abstract class Operation {
	private double numberA = 0;
	private double numberB = 0;
	boolean flag = true;

	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 abstract double getResult();
}

//加法类
class OperationAdd extends Operation {

	public double getResult() {
		return getNumberA() + getNumberB();
	}
}

//减法类
class OperationSub extends Operation {

	public double getResult() {
		return getNumberA() - getNumberB();
	}
}

//乘法类
class OperationMul extends Operation {

	public double getResult() {
		return getNumberA() * getNumberB();
	}
}

//除法类
class OperationDiv extends Operation {

	public double getResult() {
		return getNumberA() / getNumberB();
	}
}

//简单运算工厂类
class OperationFactory {
	public static Operation createOperation(char 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;
	}
}

实现二

import java.util.Scanner;

public class main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strA = sc.nextLine();
		System.out.println("请输入运算符号（+、—、*、/）：");
		String stroper = sc.nextLine();
		System.out.println("请输入数字B：");
		String strB = sc.nextLine();
		Operation oper = OperationFactory.createOperation(stroper.charAt(0));
		oper.setNumberA(Double.parseDouble(strA));
		oper.setNumberB(Double.parseDouble(strB));
		System.out.println("结果是：" + oper.getResult());

	}
}

abstract class Operation {
	private double numberA = 0;
	private double numberB = 0;
	boolean flag = true;

	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 abstract double getResult();
}

//加法类
class OperationAdd extends Operation {

	public double getResult() {
		return getNumberA() + getNumberB();
	}
}

//减法类
class OperationSub extends Operation {

	public double getResult() {
		return getNumberA() - getNumberB();
	}
}

//乘法类
class OperationMul extends Operation {

	public double getResult() {
		return getNumberA() * getNumberB();
	}
}

//除法类
class OperationDiv extends Operation {

	public double getResult() {
		return getNumberA() / getNumberB();
	}
}

//简单运算工厂类——增加求m的n次方运算
class OperationFactory {
	public static Operation createOperation(char 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;
		case '^':
			oper = new OperationMN();
		}
		return oper;
	}
}

//增加求m的n次方类
class OperationMN extends Operation {

	public double getResult() {
		double r = 0;
		double m = getNumberA();
		int n = (int) getNumberB();
		for (int i = 0; i <= n; i++) {
			r = r * m;
		}
		return r;
	}

}

优点：

二厂类中包含了必妥的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖

缺点：

在某种和度上违背了开放-封闭原则： 系统扩展困难，一旦添加新产品就得修改二厂类。
对工厂类过于依赖： 厂 类集中了所有产品创建逻辑，一旦不能正常二作， 整个系统都要受到影响。

工厂方法模式—简单计算器


public class main1 {

	public static void main(String[] args) {
		IFactory iFactory = new AddFactory();
		Operation operation = iFactory.CreateOperation();
		operation.setNumberA(1);
		operation.setNumberB(2);
		double result = operation.GetResult();
		System.out.println("结果: " + result);
	}

}

interface IFactory {
	Operation CreateOperation();
}

//加法类工厂
class AddFactory implements IFactory {

	public Operation CreateOperation() {
		return new OperationAdd();
	}
}

// 减法类工厂
class SubFactory implements IFactory {

	public Operation CreateOperation() {
		return new OperationSub();
	}
}

// 乘法类工厂
class MulFactory implements IFactory {

	public Operation CreateOperation() {
		return new OperationMul();
	}
}

// 除法类工厂
class DivFactory implements IFactory {

	public Operation CreateOperation() {
		return new OperationDiv();
	}
}

//运算类
abstract class Operation {
	private double numberA = 0;
	private double numberB = 0;

	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 abstract double GetResult();

}

//加法类
class OperationAdd extends Operation {

	public double GetResult() {
		// TODO Auto-generated method stub
		double result = 0;
		result = getNumberA() + getNumberB();
		return result;
	}
}

//除法类
class OperationDiv extends Operation {

	@Override
	public double GetResult() {
		double result = 0;
		result = getNumberA() / getNumberB();
		return result;
	}
}

//乘法类
class OperationMul extends Operation {

	@Override
	public double GetResult() {
		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}

}

//减法类
class OperationSub extends Operation {

	@Override
	public double GetResult() {
		// TODO Auto-generated method stub
		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}

}

抽象工厂模式—数据库访问程序
版本1:

public class main2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		User user = new User();
		SqlserverUser sqlserverUser = new SqlserverUser();
		sqlserverUser.Insert(user);
		sqlserverUser.GetUser(1);

	}

}

//用户对象
class User {
	private int _id;
	private String _name;

	public int get_id() {
		return _id;
	}

	public void set_id(int _id) {
		this._id = _id;
	}

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}
}

//sql Server数据库操作user
class SqlserverUser {
	public void Insert(User user) {
		System.out.println("SQL Server中给User表添加一条记录");
	}

	public User GetUser(int id) {
		System.out.println("SQL Server中根据id得到User表中的一条纪录");
		return null;
	}
}
  • 分析:这里因为SqlserverUser sqlserverUser=new SqlserverUser();
  • 这行代码写死在SqlServer了,即没有灵活性。 如果这里具有灵活性(多态),那么在执行 sqlserverUser.Insert(user);
  • sqlserverUser.GetUser(1); 这两句代码时就不用考虑是哪个数据库了。

版本二:使用抽象工厂模式。

public class main2 {

	public static void main(String[] args) {
		User user = new User();
		IFactory factory = new SqlServerFactory();
		IUser iUser = factory.CreateUser();
		iUser.InsertUser(user);
		iUser.GetUser(1);
		Department department = new Department();
		IDepartment iDepartment = factory.createDepartment();
		iDepartment.Insert(department);
		iDepartment.GetDeparment(1);

	}
}

//用户接口--->抽象产品A
interface IUser {
	void InsertUser(User user);

	User GetUser(int id);

}

//部门接口--->抽象产品B
interface IDepartment {
	void Insert(Department department);

	Department GetDeparment(int id);

}

//抽象工厂
interface IFactory {
	IUser CreateUser();

	IDepartment createDepartment();

}

//Access数据库访问--->具体工厂1
class AccessFactory implements IFactory {

	@Override
	public IUser CreateUser() {
		return new AccessUser();// 类的实例化放在子类中,封装new AccessUser()所造成的变化
	}

	@Override
	public IDepartment createDepartment() {
		return new AccessDepartment();
	}

}

//SqlServer数据库--->具体工厂2
class SqlServerFactory implements IFactory {

	@Override
	public IUser CreateUser() {
		return new SqlserverUser();
	}

	@Override
	public IDepartment createDepartment() {
		return new SqlserverDepartment();
	}

}

//具体产品类A
class SqlserverUser implements IUser {

	@Override
	public void InsertUser(User user) {
		System.out.println("SQL Server中給User表添加一条记录");

	}

	@Override
	public User GetUser(int id) {
		System.out.println("SQL Server中根據id得到User表中的一条记录");
		return null;
	}

}

//具体产品类A
class AccessUser implements IUser {

	@Override
	public void InsertUser(User user) {
		System.out.println("在Access中給User表添加一条记录");
	}

	@Override
	public User GetUser(int id) {
		System.out.println("在Access中根據id查找User表的一条记录");
		return null;
	}

}

//具体产品类B
class SqlserverDepartment implements IDepartment {

	@Override
	public void Insert(Department department) {
		System.out.println("在SQL Server中給department表新增一条记录");
	}

	@Override
	public Department GetDeparment(int id) {
		System.out.println("在SQL Server中根據id從department表中取出一条记录");
		return null;
	}

}

//具体产品类B
class AccessDepartment implements IDepartment {

	@Override
	public void Insert(Department department) {
		System.out.println("在Access中給Department表新增一条记录");

	}

	@Override
	public Department GetDeparment(int id) {
		System.out.println("在Access中根據id得到department表中的一条记录");
		return null;
	}

}

//用户类
class User {
	private int _id;
	private String _name;

	public int get_id() {
		return _id;
	}

	public void set_id(int _id) {
		this._id = _id;
	}

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}

}

分析:
1、在使用了抽象工厂模式后,通过IFactory factory=new SqlServerFactory();这行代码来实现数据库的切换。
2、如果要新增一个表对象(抽象产品),则需要大量的改动。

版本三：借助简单工厂改进抽象工厂
去掉原有的IFactory抽象工厂即两个具体工厂,用下面的DataAccess类来代替。

public class main2 {
    public static void main(String[] args) {
        User user=new User();
        Department department=new Department();
        IUser iUser=DataAccess.CreateUser();//直接通过DataAccess获得想要的表对象
        iUser.InsertUser(user);
        iUser.GetUser(1);

        IDepartment iDepartment=DataAccess.CreateDepartment();
        iDepartment.Insert(department);
        iDepartment.GetDeparment(1);
    }

}
public class DataAccess {
    private static String db="Sqlserver";

  // 根据db来决定实例化不同的类
    public static IUser CreateUser(){
        IUser result=null;
        switch (db) {
        case "Sqlserver":
            result=new SqlserverUser();
            break;
        case "Access":
            result=new AccessUser();
            break;
        }
        return result;
    }

    public static IDepartment CreateDepartment(){
        IDepartment result=null;
        switch (db) {
        case "Sqlserver":
            result=new SqlserverDepartment();
            break;
        case "Access":
            result=new AccessDepartment();
            break;
        }
        return result;
    }

}

分析:
这样把表对象的创建放入DataAccess中,在DataAccess中通过db来判断此时是哪一个数据库,从而实例化相应的表对象,当需要修改数据库时,只需要改动db即可。
另外,在DataAccess中有大量的分支判断,代码可以通过反射进一步优化,让db变量的值在客户端被指定,而不是事前就在DataAccess中写出。

// 数据库名称
    private static String db = "Sqlserver";
    // 包名----》改成SqlserverDepartment等类所在的包名
    private static String AssemblyName = "com.hwj.www.model15.version4.";

    /*
     * 根据db来决定实例化不同的类
     */
    public static IUser CreateUser() throws Exception {
        IUser result = null;
        //通过反射来实例化相应
        result = (IUser) Class.forName(AssemblyName + db + "User").newInstance();//SqlserverUser AccessUser
        return result;
    }

    public static IDepartment CreateDepartment() throws Exception {
        IDepartment result = null;
        result = (IDepartment) Class.forName(AssemblyName + db + "Department").newInstance();//SqlserverDepartment AccessDepartment
        return result;
    }

}

工厂方法模式:
在新增一个新产品时,就要新增一个具体工厂和一个具体产品类,这样程序的拓展性就有了提高,符合了开闭原则,避免了简单工厂模式的缺点.
但是,新增产品时需要新增两个类,会增加代码量,可谓是有舍有得,具体如何要结合具体情况来使用。
抽象工厂模式:
所有工厂模式的一般形式,当抽象工厂模式退化到只有一个产品登级结构时,就变成了工厂方法模式。当工厂方法模式的工厂类只有一个时,且工厂方法为静态方法时,则又变成了简单工厂模式。
与工厂方法模式相似,抽象工厂模式隔离了具体类的生成,让客户端不清楚具体什么样的对象被创建。

Sweet y y y y u
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式（简单工厂、工厂方法、抽象工厂模式）
Elf.筱焱的博客
05-08 781
设计模式（简单工厂、工厂方法、抽象工厂模式） 一、实验目的 1.熟悉建模工具。 2.掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。 二、实验内容 1.简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot...
设计模式—（4）简单工厂、工厂模式、抽象工厂模式
洞玄之境的博客
03-21 259
（4-1） 简单工厂 模式定义 简单工厂不是设计模式，更像是一种编程习惯。它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个子类来实例化。 这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个，如果不使用简单工厂，所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户...
【设计模式（三）】创建型模式之工厂模式
路远不知归
09-29 195
【设计模式（三）】工厂模式 个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道 如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充 前言 单例模式也是Java最简单和常见的模式之一 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象 根据产品类型和抽象成都可分为==简单工厂模式、工厂方法模式和抽象工厂模式== 实际上前面介绍的单例模式，也属于工厂模式。 1.介绍 使用目
设计模式（五） — 抽象工厂模式
kavenka的博客
09-28 156
创建型设计模式——抽象工厂模式 文章目录创建型设计模式——抽象工厂模式抽象工厂模式的定义抽象工厂模式的使用场景抽象工厂模式实例小结优点缺点 抽象工厂模式的定义 为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类。 抽象工厂模式的使用场景 抽象工厂模式实例 小结 优点 缺点 ...
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8392
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
抽象工厂模式------设计模式实验报告（C++实现）
qq_51725723的博客
05-18 1321
一、实验内容 利用抽象工厂模式实现不同数据库连接。要求按照P102页6.3.2实例说明，实现类图代码，并且编写测试客户端，给出动态更换数据库的运行结果。 二．设计类图 三、类具体代码（要求有相关注释） //Connection接口： class Connection { public: //连接函数，不同的数据库有不同的连接方式,定义为虚函数，完成多态 virtual void connect() = 0 { cout << "connect sucessful!" <
设计模式——简单工厂模式、工厂方法模式、抽象工厂模式
weixin_39570293的博客
03-21 194
设计模式——简单工厂模式、工厂方法模式、抽象工厂模式简单工厂模式工厂方法模式抽象工厂模式 这三种模式都属于创建型模式，封装的是对象创建的过程。 简单工厂模式 对运算进行抽象（运算类），根据数据计算出结果。结果的运算方式不同，派生出运算子类（加减乘除）。创建哪个运算子类，怎么创建运算子类。我们把这些都放到一个新的类中去实现，对外反回一个运算类对象，这个类就是一个简单工厂类。 优点： 简单直接 缺点...
吉林大学软件设计模式平时作业
02-19
作业中的"homework5.20"可能代表第五次作业，主题可能是关于设计模式的某一类别或特定模式的实践。常见的设计模式有三种类型：创建型、结构型和行为型。下面将详细阐述这三大类设计模式的一些关键知识点： 1. 创建...
Object-Oriented Analysis & Design 课程设计作业.zip
01-05
- **设计模式**：预定义的解决方案模板，如工厂模式、单例模式、观察者模式等，用于解决常见设计问题。 - **接口设计**：定义对象间的交互方式，提高系统的灵活性和可扩展性。 - **架构设计**：确定系统的整体...
java-programming-1：CypherSchool Java培训作业解决方案
02-18
9. **设计模式**：可能涉及单例、工厂、观察者等常见设计模式的应用。 10. **单元测试**：JUnit的使用，编写和运行测试用例。 这些知识点构成了一个全面的Java学习路径，对于任何想要深入理解和掌握Java编程的人来...
SE2-assignments-and-projects:这是一个用于组织准备提交的II作业的文件夹
05-15
- 在实际项目中，常见的设计模式如单例、工厂、观察者、装饰器等，能提高代码的可维护性和可扩展性。 8. **项目开发流程**： - **需求分析**：明确项目的目标和功能。 - **设计阶段**：制定架构和模块划分，可能...
AT-CS-Unit-4:来自 CS 的第 4 单元作品
07-11
8. **设计模式**：可能会介绍一些常见的设计模式，如单例模式、工厂模式、装饰器模式等。 9. **测试与调试**：单元测试、集成测试的基本方法，以及如何利用IDE进行代码调试。 10. **标准库使用**：讲解Java标准库...
软件设计模式与体系结构实验——2.1-1（2）（抽象）工厂模式的应用
m0_52435951的博客
04-26 2889
使用工厂方法模式设计的汽车保险管理应用程序实例， 设计并且实现了豪华( Super）和中等(Medum)别墅（House)和公寓(Condo)的查询。
工厂方法模式（Factory Method Pattern）
打盹儿的博客
07-17 1038
工厂方法模式概述与demo实现
抽象工厂模式
光临天下
07-19 4309
抽象工厂模式（Abstract FactoryPattern）围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
创建型模式之抽象工厂模式实例及代码操作
夏曦
12-15 1895
场景 例题:一座现代化兵工厂能根据国防需要生产各种兵器，例如机关枪、手枪和狙击步枪等等。根据国家需要，该兵工厂增加制造子弹的生产线，能够制造机关枪子弹、手枪子弹和狙击步枪子弹。 传统解决方法 缺陷： 抽象工厂模式 概念 产品等级结构 即产品的继承结构 产品簇 由同一个工厂生产的，位于不同产品等级结构中的一组产品 模式结构 抽象工厂模式结构包括4个角色： （1）抽象产品类（AbstractProduct） 一般存在多个抽象产品类，每个抽象产品定义一个产品等级 （2）具体产品类（ConcreteProd
Java抽象工厂模式（附实例代码）每天一学设计模式
weixin_42199290的博客
02-14 3242
抽象工厂模式：提供一个创建一系列相关或者相互依赖的接口，而无需指定它们具体的类。 （1）AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。 （2）ConcreateFactory（）： （3） （4） ...
设计模式之工厂方法模式、抽象工厂模式的概念和实现及使用“反射技术+读取配置文件”的方法对工厂模式进行改进（软件工程综合实践课程第三周个人作业）
GCTTTTTT的博客
09-24 869
软件工程综合实践课程第三周个人作业（工厂方法模式、抽象工厂模式的概念和实现及使用“反射技术+读取配置文件”的方法对工厂模式进行改进）
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
工厂模式详解：简单工厂、抽象工厂与工厂方法
在工厂方法模式中，通常会有一个抽象工厂类，它定义了创建产品的接口，而具体的创建过程则由其子类实现。这样做的好处是，客户端代码只需要与抽象工厂交互，无需关注具体的产品实现，提高了代码的可扩展性和灵活性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sweet y y y y u

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值