再次回顾设计模式——策略模式

  设计模式之前是学过的,这次报软考既是复习又是提高。软考需要通过java学习设计模式,之前学的虽然是C#,但设计模式的思想是一样的。话不多说直奔主题,下面先了解一下什么事策略模式。

  策略模式定义了算法家族,分别封装起来,让它们之间可以互相转换,此模式让算法的变化不会影响到使用算法的客户。

  举个例子:

  现在有一个鸭子父类,我们需要它的之类有绿头鸭、红头鸭。只需要在父类里面写一个虚方法display然后让子类去重写,绿头鸭的display就实现绿色的头,红头鸭就实现红色的头。现在让所有的鸭子都能飞,实现起来也比较简单,在父类里面添加一个fly的方法就可以了。同样的道理如果需要所有的鸭子都会叫,在父类里面添加quack方法就能实现。

  那么问题来了,现在我们有一只橡皮鸭也继承于父类。橡皮鸭会叫不会飞,但是它不会像真鸭子那样呱呱叫,橡皮鸭只能吱吱叫。我们只能在橡皮鸭子类覆盖父类的fly方法让它什么也不做,然后覆盖quack方法让它吱吱叫。

  再延伸一下现在又来了一只木头假鸭不会飞也不会叫。同样让它继承父类然后覆盖父类的fly和quack方法,让这两个方法什么也不做。

  这样做确实把橡皮鸭和木头鸭都实现了,但是橡皮鸭中根本不需要fly方法,木头鸭中也不需要fly和quack方法,却都要在写一遍覆盖掉父类,简直就是画蛇添足。更痛苦的是再添加新的鸭子进来就得考虑是不是需要覆盖父类的fly和quack。那怎么办好呢?

  这时候我们就需要把应用中可能变化的部分独立出来,不会再影响到其他部分。

  在这个例子中也就是把飞行行为和叫行为从Duck类中分离出来,鸭子类就不再需要知道行为的实现细节。类图如下:

  

  代码实现:

  

//鸭子类
public abstract class Duck{
	FlyBehavior flyBehavior;//实例化飞行对象
	QuackBehavior quackBehavior;//实例化叫对象
	public Duck(){

	}
	public abstract void display();//表现的虚方法

	public void performFly(){
		flyBehavior.fly();
	}

	public void performQuack(){
		quackBehavior.quack();
	}

	public void swim(){
		System.out.println("All ducks float,even decoys");
	}
}

//绿头鸭类
public class MallardDuck extends Duck{
	public MallardDuck(){
		quackBehavior=new Quack();
		flyBehavior=new FlyWithWings();
	}

	public void display(){
		System.out.println("I'm a real Mallard duck");
	}
}
//飞行行为接口
public interface FlyBehavior{
	public void fly();
}
//会飞行为实现
public class FlyWithWings implements FlyBehavior{
	public void fly(){
		System.out.println("I'm flying!");
	}
}
//不会飞行为实现
public class FlyNoWay implements FlyBehavior{
	public void fly(){
		System.out.println("I can't fly");
	}
}
//叫行为接口
public interface QuackBehavior{
	public void quack();
}
//呱呱叫行为实现
public class Quack implements QuackBehavior{
	public void quack(){
		System.out.println("Quack");
	}
}
//不会叫行为实现
public class MuteQuack implements QuackBehavior{
	public void quack(){
		System.out.println("<Silence>");
	}
}
//吱吱叫行为实现
public class Squeak implements QuackBehavior{
	public void quack(){
		System.out.println("Squeak");
	}
}
//主函数
public class MiniDuckSimulator{
	public static void main(String[] args){
		Duck mallard=new MallardDuck();
		mallard.performQuack();
		mallard.performFly();
	}
}

运行结果:

  

  优点:

  1、 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类里面,从而避免重复的代码。

   2、 策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式,那么使用算法或行为的环境类就可能会有一些子类,每一个子类提供一个不同的算法或行为。但是,这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起,从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。

  3、 使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护,它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起,统统列在一个多重转移语句里面,比使用继承的办法还要原始和落后。

  缺点:

  1、客户端必须知道所有的策略类,并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别,以便适时选择恰当的算法类。换言之,策略模式只适用于客户端知道所有的算法或行为的情况。

  2、 策略模式造成很多的策略类,每个具体策略类都会产生一个新类。有时候可以通过把依赖于环境的状态保存到客户端里面,而将策略类设计成可共享的,这样策略类实例可以被不同客户端使用。换言之,可以使用享元模式来减少对象的数量。

时间: 2024-11-05 22:07:32

再次回顾设计模式——策略模式的相关文章

设计模式 - 策略模式(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

head first 设计模式 策略模式

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

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

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

设计模式回顾:策略模式、代理模式、装饰者模式的区别

前言 设计模式有很多,但设计模式的目的是一致的,都是为了提升代码的可读性和可扩展性.设计模式都遵循一些基本的原则,设计模式是为了遵循这些原则而创造的工具. - 单一职责原则:就一个类而言,应该仅有一个引起它变化的原因.这一点是说,如果有一些类过于臃肿,承担了过多的职责,就应当分解他. - 开放-封闭原则:软件实体(类.模块.函数等)应该可以扩展,但是不可修改.这一点是说,拒绝硬编码,拒绝直接修改原有代码. - 依赖倒转原则:高层模块不应该以来低层模块.两个都应该以来抽象.抽象不应该依赖细节.细节