设计模式之策略模式

最新推荐文章于 2025-08-15 15:34:00 发布
原创 最新推荐文章于 2025-08-15 15:34:00 发布 · 528 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #oo #设计 #java

首先我们来设定一下场景，Link上班的公司，设计了一款游戏，游戏中会出现各种人，人们会说话，这是基本的Person类，采用OO的技术，设计成了一个superclass，并让各种不同的人类继承这个超类。

初始版0.0

通常的做法是设计成如下的样子：

具体的程序的定义的类的代码如下，其中的show方法，是因为每个人的外观不同，所以基类的show方法是抽象的方法；所有的人都会说话（speak ）。具体的代码定义如下：
Person.java
package wyhllk.blog.csdn.com;

public abstract class Person {
	public void speak() {
		System.out.println("speak English");
	}

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

	abstract void show();
}
American.java
package wyhllk.blog.csdn.com;

public class American extends Person {
	@Override
	void show() {
		System.out.println("American show()");
	}
}
Britisher.java
package wyhllk.blog.csdn.com;

public class Britisher extends Person {
	@Override
	void show() {
		System.out.println("Britisher show()");
	}
}
Chinese.java
package wyhllk.blog.csdn.com;

public class Chinese extends Person {
	@Override
	public void speak() {
		System.out.println("speak Chinese");
	}

	@Override
	void show() {
		System.out.println("Chinese show()");

	}

}
Robot.java
package wyhllk.blog.csdn.com;

public class Robot extends Person {

	@Override
	void show() {
		System.out.println("Robot show()");
	}

}

现在Link的老板说需求发生了变化，我们需要让所有的人都加上吃这个特性，初来乍到的Link很容易想到的方法就是在Person这个基类中，加入eat()方法，然后让所有的子类继承这个方法。此时的Person第二天测试的时候发现，原来的Robot现在也会吃了，但是Robot是不需要吃的。Link忽略了一件事情，并非所有的人都是会吃的，Link在基类中加入了eat的行为，会使得某些不合适的该行为的子类也具有该行为。
对代码所做的局部修改，影响层面可不只是局部！

进阶版1.0

Link想到的办法是在原来的Robot中重写eat()办法，变成什么也不做，把原来的基类中的eat()方法覆盖掉，就像Chinese中覆盖speak办法一样。
可是这样做会有一个问题：假如以后要加入一个木头人(Wooden )，不会说(speak)，也不会吃(eat),那该如何呢？

进阶版2.0

Link认识到继承可能解决不了这个问题，产品的需求可能会经常的改变，每当有新人类出现的时候，他就需要被迫的检查并可能需要覆盖speak和eat()……这将是一个无尽的噩梦。所以，Link需要一个更加清晰的方法，让“某些”（而不是全部）人类或可speak或eat
Link的办法是，把speak和eat从基类中抽取出来，放到一个Speakable接口和Eatable接口中，这样一来，只有会说的人和会吃的人才需要实现这个接口，这样就变成了下图所示的情况：


但是这样又存在问题：
  • 如果原来已经实现了很多的子类，那么每个类都需要修改eat的行为
  • 这样会造成很多的代码重复，无法的复用
这样做是从一个噩梦到另外一个噩梦

进阶版3.0

通过上面的几种尝试，Link知道了，使用继承并不能够很好的解决问题，因为人的行为在子类里面不断的改变，并且让所有的子类都有这些行为是不恰当的。Speakable接口和Eatable接口，一开始的时候似乎还是不错的，解决了问题（只有会吃的人才继承Eatable接口），但是Java的接口不具有实现代码，所以继承接口无法达到代码的复用。这意味着：无论何时你需要修改某个行为，你必须得往下追踪并在每个定义此行为的类中修改它，一不小心，可能会造成新的错误。

设计原则1：

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

换句话说：

如果每次新的需求一来，都会使某方面的代码发生变化，那么你就可以确定，这部分的代码需要被抽出来，和其他稳定的代码有所区分。

那么现在按照这个原则设计

抽离变化和不变化的部分

我们知道Person类内的speak和eat会随着人的不同而改变，为了分开变化和不会变化的部分，我们建立两组类，一个是speak相关的，一个是eat相关的，每组类将实现各自的动作。比方说，我们实现一个类实现“speak English”，一个类实现“speak Chinese”，一个类实现“quite”。

设计Person的行为

如何设计那组实现speak和eat的行为的类呢？
目标：一切都有弹性，指定行为到人的实例。比方说，我们想要产生一个新的American实例，并指定特定的“类型”的eat给他。也就是说人的行为可以动态的改变。在换句话说，我们应该在Person类中包含设定行为的方法，这样就可以在“运行时”动态“改变”American的eat的行为。
设计原则2：
针对接口编程，而不是针对实现编程
我们利用接口代表每个行为，比方说，EatBehavior与SpeakBehavior，而行为的每个实现都将实现其中的一个接口。
所以这次Person类不会负责实现Eatable和Speakable接口，反而是由我们制造一组其他类专门实现EatBehavior与SpeakBehavior，这就成为“行为”类。由行为类而不是Person类来实现行为接口。
之前的做法是：行为来自Person超类的具体实现，或是继承某个接口并由子类实现而来。这两种做法都是依赖于“实现”，我们被绑的死死的，没有办法改变行为（除非写更多的代码）。
现在我们的设计中，Person的子类使用接口（EatBehavior与SpeakBehavior）所表现的行为，所以实际的“实现”不会被绑死在Person的子类中。换句话说，特定的具体实现行为编写在实现了EatBehavior与SpeakBehavior类中了。

实现Person的行为

设计的类图如下：


这样设计可以让speak和eat的动作被其他的对象复用，因为这些行为已经和Person无关了。而我们新增的一些行为不会影响到既有的行为类，也不会影响“使用”到eat行为的人类。

整合这些行为

关键在于，Person现在会将speak和eat的动作“委托”别人处理，而不是使用Person类（或子类）内的speak和eat方法。
  • 首先，在Person类中“加入两个实例变量”，分别为“speakBehavior”和“eatBehavior”，声明为接口类型（而不是具体类实现类型），每个人类对象都会动态地设置这些变量一种以在运行时引用正确的行为类型（例如：EatWithMouse、SpeakChinese等）。
我们也必须将Person类与其子类中的speak()和eat删除，因为这些行为已经搬到了SpeakBehavior和EatBehavior类中了
我们用两个相似的方法performEat()和performSpeak()取代Person类中的eat()和speak()。

  • 现在，实现performEat():
package wyhllk.blog.csdn.com;

public abstract class Person {
	EatBehavior eatBehavior;
	public void performEat(){
		eatBehavior.eat();
	}
	public void speak() {
		System.out.println("speak English");
	}
//还有其他的
}
  • 现在，整合所有的代码如下：
Person.java
package wyhllk.blog.csdn.com;

public abstract class Person {
	EatBehavior eatBehavior;
	SpeakBehavior speakBehavior;

	public void performEat() {
		eatBehavior.eat();
	}

	public void performSpeak() {
		speakBehavior.speak();
	}

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

	abstract void show();
}
EatBehavior.java
package wyhllk.blog.csdn.com;

public interface EatBehavior {
	void eat();
}
EatWithMouse.java
package wyhllk.blog.csdn.com;

public class EatWithMouse implements EatBehavior {

	@Override
	public void eat() {
		System.out.println("I can eat!");
	}

}
EatNoWay.java
package wyhllk.blog.csdn.com;

public class EatNoWay implements EatBehavior {

	@Override
	public void eat() {
		System.out.println("I can't eat");
	}

}
SpeakBehavior.java
package wyhllk.blog.csdn.com;

public interface SpeakBehavior {
	void speak();
}
SpeakEnglish.java
package wyhllk.blog.csdn.com;

public class SpeakEnglish implements SpeakBehavior {

	@Override
	public void speak() {
		System.out.println("speak English");
	}

}
SpeakChinese.java
package wyhllk.blog.csdn.com;

public class SpeakChinese implements SpeakBehavior {

	@Override
	public void speak() {
		System.out.println("speak Chinese");
	}

}
SpeakQuite.java
package wyhllk.blog.csdn.com;

public class SpeakQuite implements SpeakBehavior {

	@Override
	public void speak() {
		System.out.println("<<quite>>");
	}

}
编写的新的人类，外星人大笑
Alien.java
package wyhllk.blog.csdn.com;

public class Alien extends Person {

	public Alien() {
		eatBehavior = new EatWithMouse();
		speakBehavior = new SpeakEnglish();
	}

	@Override
	void show() {
		System.out.println("I am Alien");
	}

}
最后编写一个测试类
package wyhllk.blog.csdn.com;

public class MiniPersonSimulator {

	public static void main(String[] args) {
		Person person = new Alien();
		person.performEat();
		person.performSpeak();
	}

}
运行的结果如下：


终极版

上面虽然实现了功能，但是并没有实现运行时的动态的设定行为。
  • 要实现这个功能，只需要在Person类中加入两个setter方法即可：
	public void setEatBehavior(EatBehavior eatBehavior) {
		this.eatBehavior = eatBehavior;
	}

	public void setSpeakBehavior(SpeakBehavior speakBehavior) {
		this.speakBehavior = speakBehavior;
	}
这样就可以“随时”调用这个方法改变人类的行为了。
  • 可以制造一个模型人
ModelPerson.java
package wyhllk.blog.csdn.com;

public class ModelPerson extends Person {

	public ModelPerson() {
		eatBehavior = new EatNoWay();
		speakBehavior = new SpeakEnglish();
	}

	@Override
	void show() {
		System.out.println("I am ModelPerson");
	}

}
创建一个测试类
MiniPersonSimulator.java
package wyhllk.blog.csdn.com;

public class MiniPersonSimulator {

	public static void main(String[] args) {
		Person model = new ModelPerson();
		model.performSpeak();
		model.setSpeakBehavior(new SpeakChinese());
		model.performSpeak();
	}

}

测试的结果：


总结

通过上面的一系列的演变过程，我们得到了一个全新的设计之后的类结构，Link所期望的一切都有：人类继承Person，吃的行为实现EatBehavior接口，说的行为实现SpeakBehavior接口。
下面注意来点儿专业术语了。不再把人类的行为说成是“一组行为”，我们开始把行为想成是“一族算法”。想想看，在整个设计当中，算法代表人类能做的事（不同的吃法和说法）。
设计原则3：
多用组合，少用继承
通过上面的过程，我们抽象出一般的模型：



策略模式

定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。


参考文献：
《Head First设计模式》
《设计模式-可复用面向对象软件的基础》
23种设计模式之策略模式
JAVA开发区的博客
05-27 1157
策略模式，又称政策模式，是行为型设计模式之一。其定义如下：定义一系列算法，把它们一个个封装起来，并且使它们互相替换。本模式使得算法可独立于使用它的客户而变化。策略接口是所有策略类的共同父接口，它定义了所有策略类必须实现的方法。策略模式作为一种行为型设计模式，通过将算法封装成独立的策略类，实现算法的易于扩展和高可维护性，避免了大量的条件分支语句，使得代码更加清晰、简洁。策略模式在排序算法、支付方式、数据压缩、游戏AI行为等场景中广泛应用。
JavaSE学习17（Lambada表达式）
weixin_44643735的博客
11-19 424
Lambada表达式 1.1 函数式编程思想概述 在数学中，函数就是有输入量，输出量的一套计算方案，也就是 拿数据做操作 学习的这个Lambda表达式就是函数式思想的体现 强调的是做什么 1.2 体验Lambda表达式 需求：启动一个线程，在控制台输出一句话，多线程启动了 代码： public class LambdaDemo { public static void m...
求迷宫的最短路径
wyhllk的专栏
05-29 1630
迷宫的表示是一个N×M的二位数组，左上角的位置(0,0)是入口，右下角的位置(N-1,M-1)是迷宫的出口，其中的1表示迷宫不能走，0表示可以行走，本文使用类似的A*算法来进行寻路。 首先是定义个一个点的类，Poin表示迷宫的每个点的位置，如下： package wyhllk.algorithm; /** * @author wyhllk * */ public class Point
Java类的定义
新手专用的博客
12-18 1017
Java类的定义
编写一个小的程序，其中定义一些接口、类、抽象类，定义它们的成员（字段及方法）等
qq_29967019的博客
06-24 7631
编写一个小的程序，其中定义一些接口、类、抽象类，定义它们的成员（字段及方法）等编写一个小的程序，其中定义一些接口、类、抽象类，定义它们的成员（字段及方法）， 要求使用使用setter/getter, static, final, abstract，@Override等语法要素，并写一个main函数来使用它们。这些类、接口可以是围绕以下选题之一我选的是动物世界 编写一个小的程序，其中定义一些接口、类...
Java-基础语法20:Lambda&方法引用
DrewWong的博客
10-31 688
1.Lambda表达式 1.1体验Lambda表达式【理解】 案例需求 启动一个线程，在控制台输出一句话：多线程程序启动了 实现方式一 实现步骤 定义一个类MyRunnable实现Runnable接口，重写run()方法 创建MyRunnable类的对象 创建Thread类的对象，把MyRunnable的对象作为构造参数传递 启动线程 实现方式二 匿名内部类的方式改进 实现方式三 Lambda表达式的方式改进 代码演示 //方式一的线程类 public class My
55-Java设计模式之策略模式与状态模式1
08-08
Java 设计模式之策略模式与状态模式 策略模式是 Java 中的一种设计模式，它主要用于解决系统与第三方接口进行数据交互的问题。当系统需要与多种格式的数据进行交互时，使用策略模式可以很好地解决这个问题。例如，...
设计模式之策略模式，商场收银，封装算法
11-08
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或场景来执行不同算法的情况。策略模式就是为了解决这类问题而提出的，它将每种算法封装到具有共同接口...
函数式接口、方法引用
huangyh技术栈
08-14 1389
1.1函数式接口： 1.1.2 概念和格式： 什么是函数式接口: 接口中有且只有一个抽象方法则称为函数式接口。 常见的函数式接口： Runnable、Callable、Comparator、FileFilter 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，...
接口作业的笔记之简答题
sugar_sugar_sugar的博客
12-01 2125
以下代码加上了我的想法测试，合理的都能完美运行 二· 1. public interface Utility{} class Phone implements Utility{  void use(){  System.out.println("using phone");  } } public class Test{  public static v
java面向对象接口课后第五题 及基础知识点
m0_48220895的博客
06-14 306
接口的作用 代表一种能力，主要是解决java中单继承的局限性 接口的声明 接口就是用来被继承的，被实现的，因此修饰符一般建议使用public或默认即可； 不能使用private和protected修饰接口。interface关键字用来声明一个接口。 //接口的声明 interface Animal { //静态常量成员 public static final int AGE = 5; //抽象方法成员 public void eat();
【C#】委托和事件
柠檬树
09-25 820
一、前提：         最近在备战软考，复习观察者模式的过程中再次接触到了委托和事件。可谓是一脸懵逼啊，看来欠下的总是要还的，当初委托和事件匆匆而过，没有留下丝毫痕迹，今天还需再战。 二、生活中类“委托”示例：          张三、李四、王五三个人是大学同学，一天，他们三个人同时收到了申通快递的短信，需要去拿快递，由于王五吃苦耐劳，为人陈恳。因此，张三、李四一合计，把取快递的
第二章第六天接口
qq_40115919的博客
08-08 781
接口的概述 接口：接口就是一组功能（能力/规范） 特点： 实现多态 解决了继承的单一继承的问题。 注意事项： 多组合，帮助程序功能与功能之间解耦，程序的扩展性好、维护性好 接口侧重能力，忽略实现细节 面向接口编程，一个接口可以同时继承多个接口   例一、 对贯穿本书的案例电子宠物系统的类结构进行重构，要求如下： 定义Eatable接口，在接口中定义eat()方法，表示吃饭功能 定...
JAVA-接口中定义抽象方法及使用{笔记}
QL_DIANDIAN的博客
09-27 8579
接口的定义 在接口中定义抽象方法的时候 （抽象方法的一般格式;public abstract 返回值类型 方法名（）；） (1)但是在接口中抽象方法，修饰符必须是两个固定的关键字 public abstract (2)其中public abstract 可以省略 (3)方法的三要素可以随意更改 public interface Myinterface { //以下都可以 public abstract void method(); public void method1(); abstract
Java 工厂方法模式
小凯的博客
08-12 1091
深入理解 Java工厂方法模式
【软件设计模式】前置知识类图、七大原则（精简笔记版）
最新发布
m0_74808313的博客
08-15 449
本文系统介绍了软件设计中的UML类图与面向对象设计原则。UML类图部分详细解析了类的基本表示方法（类名、属性、操作）和五种核心关系（泛化、聚合、组合、依赖、关联），并说明了接口实现与多重性表示方法。设计模式部分阐述了其四大要素（名称、问题、解决方案、效果）和三大分类（创建型、结构型、行为型），列举了GoF23种经典模式。最后重点讲解了面向对象七大设计原则，包括单一职责、开闭原则、里氏替换等，强调通过抽象、组合等方式实现高内聚低耦合的系统设计。这些知识为构建可扩展、可维护的软件系统提供了方法论指导。
设计模式学习笔记-----单例模式
2301_80860862的博客
08-13 811
单例模式是一种确保类只有一个实例并提供全局访问点的设计模式。常见实现方式包括：1）饿汉式（类加载时创建实例，线程安全但可能浪费资源）；2）枚举饿汉式（利用枚举特性防止反射/序列化破坏）；3）懒汉式（延迟加载，需处理线程安全问题）；4）DCL双重检查锁（volatile防止指令重排序）；5）静态内部类（利用类加载机制保证线程安全）。JDK中典型应用包括Runtime（饿汉）、System（DCL）和Collections（内部类）等。每种实现各有优劣，需根据线程安全、性能、序列化等需求选择。
策略模式实战应用与HeadFirst设计模式学习
根据提供的文件信息，以下是关于“HeadFirst 设计模式学习笔记1--策略模式Demo”的知识点梳理： **标题解读：** 标题中提到的“HeadFirst 设计模式学习笔记1--策略模式Demo”指出了这份文档是关于“策略模式”的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值