设计模式学习--策略模式(Strategy Pattern)

时间:2021-02-13 21:59:45

设计模式学习--策略模式(Strategy Pattern)

什么是策略模式?

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

怎么使用策略模式设计程序?

分开变化和不会变化的部分,建立一组新的类来代表变化的部分。

三个设计原则:

1. 找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。 2. 针对接口编程,而不是针对实现编程。 3. 多用组合,少用继承。

策略模式应用例子:

一只鸭Duck,可能是以下几种不同类型的鸭 (MallardDuck) 绿头鸭--会飞会呱呱叫 (RedHeadDuck) 红头鸭--会飞会呱呱叫 (RubberDuck) 橡皮鸭--不会飞会叽叽叫 (DecoyDuck) 诱饵鸭--不会飞也不会叫 (ModelDuck) 模型鸭--不会飞也不会叫

在没有使用策略模式之前可能这样:


1. 利用继承来提供Duck的行为 ===》导致代码在多个子类中重复 ===》运行时的行为不容易改变 ===》很难知道所有鸭子的全部行为 ===》改变会牵一发动全身,造成其他鸭子不想要的改变。 2. 把会变的行为提取出来设计成一个接口 ===》导致重复代码变多 ===》导致代码无法进行复用


使用策略模式会是这样:

1. 采用良好的oo软件设计原则 2. 分开变化和不会变化的部分 3.  针对接口编程

具体实现: 所有类型鸭的抽象:Duck类
package strategyPattern;

/**
* 所有类型鸭子的超类
* @author wwj
*
*/
public abstract class Duck {
FlyBehavior flyBehavior;//飞行行为
QuackBehavior quackBehavior;//呱呱叫行为

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

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

public abstract void display();

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

public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}

public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}

}


把会变化的部分取出并“封装”起来,好让其他部分不会受到影响 提供两个接口FlyBehavior和QuackBehavior
package strategyPattern;

public interface FlyBehavior {
public void fly();
}

package strategyPattern;

public interface QuackBehavior {
public void quack();
}

实现鸭子的行为(飞行类)
package strategyPattern;

public class FlyWithWings implements FlyBehavior {

@Override
public void fly() {
//实现鸭子飞行
System.out.println("I'm flying!");
}

}

package strategyPattern;

public class FlyNoWay implements FlyBehavior {

@Override
public void fly() {
//什么都不做,不会飞
System.out.println("I can't fly");
}

}


public class FlyRocketPowered implements FlyBehavior {

@Override
public void fly() {
System.out.println("I'm flying with a rocket!");
}

}


实现鸭子的行为(呱呱叫)
package strategyPattern;

public class Quack implements QuackBehavior {

@Override
public void quack() {
//实现鸭子呱呱叫
System.out.println("Quack");
}

}

package strategyPattern;

public class Squack implements QuackBehavior {

@Override
public void quack() {
//橡皮鸭子叽叽叫
System.out.println("Squack");
}

}

package strategyPattern;

public class MuteQuack implements QuackBehavior {

@Override
public void quack() {
// 什么都不做,不会叫
}

}

整合鸭子的行为,让不同的鸭子继承鸭类(Duck)
package strategyPattern;

/**
* 绿头鸭继承鸭类
* @author wwj
*
*/
public class MallardDuck extends Duck{

/**
* 因为MallardDuck继承Duck类,所以具有flyBehavior与quackBehavior实例变量
*/
public MallardDuck() {
quackBehavior = new Quack(); //真正的呱呱叫
flyBehavior = new FlyWithWings();//会用翅膀飞
}

public void display() {
System.out.println("I'm a real Mallard duck");//我是一个真正的绿头鸭
}

}

package strategyPattern;

public class RedheadDuck extends Duck{
public RedheadDuck() {
flyBehavior = new FlyWithWings();
quackBehavior = new Quack();
}

@Override
public void display() {
System.out.println("I'm a RedheadDuck!!");//红头鸭
}

}

package strategyPattern;

public class RubberDuck extends Duck{
public RubberDuck() {
}

@Override
public void display() {
System.out.println("I'm a RubberDuck!!!");
}

}

package strategyPattern;

public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//不会飞
quackBehavior = new Quack();//会叽叽叫
}

@Override
public void display() {
System.out.println("I'm a model duck");
}

}

package strategyPattern;

public class DecoyDuck extends Duck{
public DecoyDuck(){
}

@Override
public void display() {
System.out.println("I'm a DecoyDuck!!!");//我是一只诱饵鸭
}

}

测试类:
package strategyPattern;

public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();


//动态改变模型鸭的行为--通过调用继承来的setter方法
Duck model = new ModelDuck();
model.performFly();
model.setFlyBehavior(new FlyRocketPowered());//委托
model.performFly();
}
}


测试结果:
Quack
I'm flying!
I can't fly
I'm flying with a rocket!


确实,使用策略模式之后,代码变得可复用了,可以适应更多的变化,而不会互相影响。良好的oo设计必须具备可复用、可扩充、可维护三个特性。模式是前人历经验证的经验,可以用来解决程序设计当中的各种问题。