软件开发的一个不变的真理---CHANGE
拥抱变化,为变化而生!
设计原则
找出可能发生变化的地方,把它们独立出来单独处理,不要和那些变化的代码混在一起!
把会变化的部分抽取并进行“封装”,以后可以轻松的改动或扩展此部分,而不影响其它不需要变化的部分!
设计原则
针对接口编程,而不是针对实现编程!
针对接口编程,真正的意思是“针对超类型编程”
抽象类、接口
抽象类持有接口的引用
继承
运行时可以动态为子类继承下来的接口指定具体实现类
设计原则
多用组合,少用继承!
将多个类结合起来使用(1个类持有其它类的引用),就是组合(composition)!
这里的其它类便是一组行为(一族算法)的封装
策略模式
定义了算法族,分别封装起来,并让它们可以相互替换。
此模式让算法的变化独立于使用算法的客户。
=======================================================================
不同类型的鸭子和它们的行为
鸭子的父类
package duck; import duck.fly.FlyBehavior; import duck.quack.QuackBehavior; public abstract class Duck { public Duck() { } /** * 共同的行为,在父类中定义即可 */ public void swim() { System.out.println("All duck float!"); } /** * 不同子类的display行为不同,只能让子类去实现 */ public abstract void display(); //============================== FlyBehavior flyBehavior;//接口,为多态提供了前提 QuackBehavior quackBehavior;//接口,为多态提供了前提 /** * 委托行为到父类中,这里是关键! */ public void performFly() { flyBehavior.fly(); } public void perfomQuack() { quackBehavior.quack(); } /** * 对外部暴露修改实现类的入口 * @param flyBehavior */ public void setFlyBehavior(FlyBehavior flyBehavior) { this.flyBehavior = flyBehavior; } public void setQuackBehavior(QuackBehavior quackBehavior) { this.quackBehavior = quackBehavior; } }
具体鸭子---野鸭
package duck; import duck.fly.impl.FlyWithSwing; import duck.quack.impl.Quack; public class MallardDuck extends Duck { public MallardDuck() { //对继承下来的属性进行默认初始化 init(); } private void init() { flyBehavior = new FlyWithSwing(); quackBehavior = new Quack(); } public void display() { System.out.println("I'm a real Mallard Duck"); } }
具体鸭子---模型鸭
package duck; import duck.fly.impl.FlyWithSwing; import duck.quack.impl.MuteQuack; public class ModelDuck extends Duck { public ModelDuck() { //对继承下来的属性进行初始化 init(); } private void init() { flyBehavior = new FlyWithSwing(); quackBehavior = new MuteQuack(); } @Override public void display() { System.out.println("I'm a model duck"); } }
鸭子飞的行为
package duck.fly; public interface FlyBehavior { void fly(); }
飞的行为(一)
package duck.fly.impl; import duck.fly.FlyBehavior; public class FlyWithSwing implements FlyBehavior { /** * 专门针对接口进行实现 * 让特定的行为脱离主线,独立出来,需要新的行为,只需要对外部进行改变即可 */ @Override public void fly() { System.out.println("fly with swing"); } }
飞的行为(二)
package duck.fly.impl; import duck.fly.FlyBehavior; public class FlyNoWay implements FlyBehavior { /** * 由行为类去实现接口,而不是让每个子类单独实现一次,提高了代码复用性 * 需要的地方直接引用这个行为类的超类接口即可---解耦,可以灵活改变行为 */ @Override public void fly() { System.out.println("fly no way"); } }
飞的行为(三)
package duck.fly.impl; import duck.fly.FlyBehavior; public class FlyRocketPower implements FlyBehavior { @Override public void fly() { System.out.println("I'm flying with a rocket!"); } }
鸭子叫的行为
package duck.quack; public interface QuackBehavior { void quack(); }
叫的行为(一)
package duck.quack.impl; import duck.quack.QuackBehavior; public class Quack implements QuackBehavior { @Override public void quack() { System.out.println("quack"); } }
叫的行为(二)
package duck.quack.impl; import duck.quack.QuackBehavior; public class Squeak implements QuackBehavior { @Override public void quack() { System.out.println("squeak"); } }
叫的行为(三)
package duck.quack.impl; import duck.quack.QuackBehavior; public class MuteQuack implements QuackBehavior { @Override public void quack() { System.out.println("<< Silence >>"); } }
测试
package test; import duck.Duck; import duck.MallardDuck; import duck.ModelDuck; import duck.fly.impl.FlyRocketPower; import duck.quack.impl.Squeak; public class DuckTest { public static void main(String[] args) { Duck mallard = new MallardDuck(); mallard.swim(); mallard.display(); mallard.performFly(); mallard.perfomQuack(); System.out.println("=======break line======="); Duck model = new ModelDuck(); model.swim(); model.display(); model.performFly(); //动态修改行为 model.setFlyBehavior(new FlyRocketPower()); model.performFly(); model.perfomQuack(); //动态修改行为 model.setQuackBehavior(new Squeak()); model.perfomQuack(); } }
另一个使用策略模式的例子
相关推荐
在《Head First 设计模式》这本书中,策略模式被详细地讲解,并通过C++代码实现来加深理解。策略模式的核心思想是定义一系列的算法,并将每一个算法封装起来,使它们可以相互替换。这使得算法的变化独立于使用算法的...
《HeadFirst策略模式》是设计模式领域的一本经典著作,其第一章主要介绍了策略模式的基本概念、原理以及在C++中的具体实现。策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。这种模式允许我们用不同的...
在《Head First 设计模式》这本书中,策略模式被用来演示如何在不修改原有代码的情况下,通过改变执行策略来改变对象的行为。例如,我们可以创建一个`SortStrategy`接口,包含`sort()`方法,然后定义不同的排序策略...
综上所述,这个压缩包提供的“Head First C++策略设计模式”示例,不仅教你如何在C++中实现策略模式,还通过类图帮助你理解面向对象设计中的一个重要概念。通过学习这个案例,你可以更好地掌握如何在实际项目中运用...
在《Head First设计模式》的第一章中,作者可能通过生动的示例和易于理解的图表,解释了如何在实际问题中识别策略模式的应用场景,以及如何有效地实现和使用这个模式。书中可能涵盖了以下内容: - 策略模式的基本...
在HeadFirst的《设计模式》一书中,作者以通俗易懂的方式介绍了各种设计模式,包括策略模式,适合初学者和有经验的开发者深入理解设计模式的原理和应用。通过阅读这本书,我们可以更好地掌握如何在实际项目中灵活...
《Head First 之策略模式源码》是一份深入解析策略模式的编程学习资源,它以Head First系列的易懂风格,结合源代码实例,帮助读者理解并掌握这一设计模式。策略模式是软件工程中的一种行为设计模式,它使你能在运行...
7. **策略模式**(Strategy):定义一系列算法,把它们一个个封装起来,并使它们可以相互替换。Java中,策略模式常用于定义算法族,方便算法的切换。 8. **模板方法模式**(Template Method):定义一个操作中的...
《Head First Design Patterns》是一本深入浅出介绍设计模式的图书,由Eric Freeman、Elisabeth Freeman、Bert Bates和Kathy Sierra联合编写。本书结合认知科学原理和神经生物学研究,采用引导式教学方法,通过故事...
行为型模式涉及对象间的交互和责任分配,包括模板方法模式(Template Method)、观察者模式(Observer)、策略模式(Strategy)、职责链模式(Chain of Responsibility)、命令模式(Command)、迭代器模式...
行为型模式则主要处理对象之间的交互和责任分配,例如策略模式(Strategy)、观察者模式(Observer)和职责链模式(Chain of Responsibility)等,它们有助于实现灵活、可扩展的行为。 《Head First设计模式》书中...
策略模式: 定义了算法族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。 The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes ...
行为型模式涉及对象之间的责任分配,包括模板方法模式(Template Method)、策略模式(Strategy)和观察者模式(Observer)。模板方法模式定义了一个操作中的算法骨架,允许子类在其间填充具体步骤;策略模式定义一...
8. **策略模式**:定义一组可互换的策略,让算法可以在运行时选择合适的策略。书中可能会有一个Context类,它使用Strategy接口,并根据需要选择ConcreteStrategyA、ConcreteStrategyB等具体策略。 9. **模板方法...
《Head First 策略者模式》学习笔记 策略者模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件开发中,我们常常遇到需要根据不同的情况执行不同算法的问题。策略者模式就是为了解决这类问题而生,它...
- 策略模式(Strategy):定义了一系列算法,并将每个算法封装起来,使它们可以互相替换。 - 模板方法模式(Template Method):在一个方法中定义一个算法的框架,而将一些步骤延迟到子类中。 通过研究《Head...