从头认识设计模式-策略模式-04-引入设计原则:分离变化与不变的部分

这一章节我们引入设计原则:分离变化与不变的部分。

1.什么是不变的部分,什么是变化的部分?

(1)不变的部分

就像我们之前的增删改查,是一个比较固定的部分,每一个新的类继承都一样,只不过可能放到里面的参数不一样而已

(2)变化的部分

就像导入导出功能,它会根据不同的业务场景,然后有不同的需求

2.我们应该怎么做?

我们应该把不变的部分单独封装成一个类。

3.代码清单

在Base里面增加导入导出类的属性域

package com.raylee.designpattern.strategy.ch04;

/**
 * 这个类是我们需要使用设计模式改进的原始类,也就是策略模式应用的初始环境。
 *
 * @author raylee
 * @data 2016-03-16
 * @version 1.0
 */
public class BaseServiceImpl {
	private Export exportObject;
	private Import importObject;

	public BaseServiceImpl() {
		exportObject = new Export();
		importObject = new Import();
	}

	public Export getExportObject() {
		return exportObject;
	}

	public Import getImportObject() {
		return importObject;
	}

	public void add() {
		System.out.println("add a new object");
	}

	public void update() {
		System.out.println("update object");
	}

	public void query() {
		System.out.println("query and return a object");
	}

	public void delete() {
		System.out.println("delete the object");
	}
}

导入导出实现类:

package com.raylee.designpattern.strategy.ch04;

public class Import {
	public void importUser() {
		System.out.println("import users");
	}

	public void importDept() {
		System.out.println("import depts");
	}

	public void importCourse() {
		System.out.println("import courses");
	}
}

package com.raylee.designpattern.strategy.ch04;

public class Export {

	public void exportUser() {
		System.out.println("export users");
	}

	public void exportDept() {
		System.out.println("export depts");
	}

	public void exportCourse() {
		System.out.println("export courses");
	}
}

在实现类里面调用导入导出的方法:

package com.raylee.designpattern.strategy.ch04;

/**
 * @TODO 1 用于用户的增删改查
 * @TODO 1.1 增加导入导出功能
 * @author raylee
 * @date 2016年3月16日
 * @version 1.1
 */
public class UserServiceImpl extends BaseServiceImpl {
	public void exportUser() {
		getExportObject().exportUser();
	}

	public void importUser() {
		getImportObject().importUser();
	}

}

package com.raylee.designpattern.strategy.ch04;

/**
 * @TODO 1 用于部门的增删改查
 * @TODO 1.1 增加导入导出功能
 * @author raylee
 * @date 2016年3月16日
 * @version 1.1
 */
public class DeptServiceImpl extends BaseServiceImpl {
	public void exportDept() {
		getExportObject().exportDept();
	}

	public void importDept() {
		getImportObject().importDept();
	}
}

package com.raylee.designpattern.strategy.ch04;

/**
 * @TODO 1 用于课程的增删改查
 * @TODO 1.1 增加导入导出功能
 *
 * @author raylee
 * @date 2016年3月16日
 * @version 1.1
 */
public class CourseServiceImpl extends BaseServiceImpl {
	public void exportCourse() {
		getExportObject().exportCourse();
	}

	public void importCourse() {
		getImportObject().importCourse();
	}
}

然后在Client里面测试导入导出

package com.raylee.designpattern.strategy.ch04;

public class Client {
	// 对用户、部门、课程进行增删改查
		public static void main(String[] args) {
			CourseServiceImpl courseServiceImpl = new CourseServiceImpl();
			courseServiceImpl.importCourse();
			courseServiceImpl.exportCourse();
			UserServiceImpl userServiceImpl = new UserServiceImpl();
			userServiceImpl.importUser();
			userServiceImpl.exportUser();
			DeptServiceImpl deptServiceImpl = new DeptServiceImpl();
			deptServiceImpl.importDept();
			deptServiceImpl.exportDept();
		}
}

输出:

import courses
export courses
import users
export users
import depts
export depts

4.问题

看上去上面的代码应该没什么问题,但是,如果我们增加的不单只是导入导出功能,而且还有其他的一些功能,我们还是需要改动原来的代码,可扩展性差。

总结:这一章节初步解决了需求变化的问题,但是还是存在不足。

目录:

我的github:https://github.com/raylee2015/designpattern

时间: 2024-10-31 23:52:25

从头认识设计模式-策略模式-04-引入设计原则:分离变化与不变的部分的相关文章

从头认识设计模式-策略模式-05-引入设计原则:面向接口编程

这一章节我们来讨论一下怎么解决上一章节扩展性差的问题. 1.解决方案 面向接口编程 2.思路 使用java的多态性,动态的设置导入导出的行为 3.代码清单 在Base里面使用导入导出的接口,然后增加一个通用的导出导入方法,下面的实现中,我们只需要设置不同的导入导出行为,即可通过导入导出方法来实现不同的导入导出结果. package com.raylee.designpattern.strategy.ch05; /** * 1.0 这个类是我们需要使用设计模式改进的原始类,也就是策略模式应用的初始

head first 设计模式 策略模式

HEAD FIRST:策略模式定义了算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户. 设计模式:定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换.本模式使得算法可独立于它的客户而变化. 大话设计模式:它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化,不会影响到使用算法的客户. 使用这个模式的原因: 用许多的算法对一类进行计算.那么如果把这些算法强行编码到这个类当中.其实是不可取的.因为很多时候下不同的情况下使用不同的算

设计模式 - 策略模式(Strategy Pattern) 具体解释

策略模式(Strategy Pattern) 具体解释 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26577879 本文版权全部, 禁止转载, 如有须要, 请站内联系. 策略模式: 定义了算法族, 分别封装起来, 让它们之间能够相互替换, 此模式让算法的变化独立于使用算法的客户. 对于父类的子类族须要常常扩展新的功能, 为了使用父类比較灵活的加入子类, 把父类的行为写成接口(interface)的形式; 使用set()方法

设计模式 - 策略模式(Strategy Pattern) 详解

策略模式(Strategy Pattern) 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26577879 本文版权所有, 禁止转载, 如有需要, 请站内联系. 策略模式: 定义了算法族, 分别封装起来, 让它们之间可以相互替换, 此模式让算法的变化独立于使用算法的客户. 对于父类的子类族需要经常扩展新的功能, 为了使用父类比较灵活的添加子类, 把父类的行为写成接口(interface)的形式; 使用set()方法,

2.大话设计模式-策略模式

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace DesignModel 8 { 9 /// <summary> 10 /// 策略模式 11 /// </summary> 12 public class TacticsModel 13 { 14 //对于

设计模式---策略模式Strategy(对象行为型)

1. 概述 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化. 策略模式是对算法的封装,它把算法的责任和算法本身分割开,委派给不同的对象管理. 2. 应用场景 (1)多个类只区别在表现行为不同,在运行时动态选择具体要执行的行为. (2)需要在不同情况下使用不同的策略(算法),或者策略还可能在未来用其它方式来实现. (3)对客户隐藏具体策略(算法)的实现细节,彼此完全独立. 3. 示例 出行旅游:我们可以有几个策略可以考虑:可

设计模式—策略模式

什么是策略模式? 策略模式定义了算法家族,分别封装起来,让它们之间能够相互替换,此模式让算法的变化不会影响到使用算法 的客户. 策略模式是一种定义一系列算法的方法,从概念上看全部这些算法完毕的都是同样的工作,仅仅是实现不同,它可 以以同样的方式调用全部的算法,降低了各种算法类与使用算法之间的耦合. 策略模式的长处? (1)策略模式的Strategy类层为Context类定义了一系列的可供重用的算法和行为.继承有助于析取出这些算法 的公共功能. (2)简化了单元測试(每一个算法都有自己的类,能够通

说说设计模式~策略模式(Strategy)

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.而对于客户端(UI)来说,可以通过IOC再配合工厂模块,实现动态策略的切换,策略模块通常于一个抽象策略对象(interface or abstract class),多个具体策略对象(implement class )和一个调用策略的入口组成. 何时能用到它? 对于UI来说,可能一个功能会有多种实现方式,而且实现方式可能还会有扩展,例如,一个ATM机,它目前支持工行,建行,家行,以后可能又出现了占占银行,而这时,ATM

15. 星际争霸之php设计模式--策略模式

题记==============================================================================本php设计模式专辑来源于博客(jymoz.com),现在已经访问不了了,这一系列文章是我找了很久才找到完整的,感谢作者jymoz的辛苦付出哦! 本文地址:http://www.cnblogs.com/davidhhuan/p/4248199.html============================================