设计模式解读之一: 策略模式
1. 模式定义
把会变化的内容取出并封装起来,以便以后可以轻易地改动或扩充部分,而不影响不需要变化的其他部分;
2. 问题缘起
当涉及至代码维护时,为了复用目的而使用继承,结局并不完美。对父类的修改,会影响到子类型。在超类
中增加的方法,会导致子类型有该方法,甚至连那些不该具备该方法的子类型也无法免除。
(可重用但不灵活): 我们知道,继承在某种程度上可以实现"代码重用",但是父类(例如鸭子类Duck)的行为在子类型中是不断变化
的,让所有子类型都有这些行为是不恰当的。
(灵活但不可重用):我们可以将这些行为定义为接口,让Duck的各种子类型去实现,但接口不具有实现代码,所以实现接口无法达到代码复用。
这意味着,当我们需要修改某个行为,必须往下追踪并在每一个定义此行为的类中修改它,一不小心,会造成新的错误。
设计原则:把应用中变化的地方独立出来,不要和那些不需要变化的代码混在一起。这样代码变化引起的不
经意后果变少,系统变得更有弹性。
1) [color=red]分开变化的内容和不变的内容:[/color]
Duck类中的行为 fly(), quack(), 每个子类型可能有自己特有的表现,这就是所谓的变化的内容。
Duck类中的行为 swim() 每个子类型的表现均相同,这就是所谓不变的内容。
2) [color=red]整合变化的内容和不变的内容:[/color]
Duck.java将 fly()以及quack()的行为委拖给行为类处理(行为类就是一些实现了fly()接口的类)。
Duck.java不关心如何进行 fly()以及quack(), 这些细节交由具体的行为类完成。
我们将变化的内容从Duck()类中剥离出来单独定义形成接口以及一系列的实现类型。将变化的内容定义形
成接口可实现变化内容和不变内容的剥离。其实现类型可实现变化内容的重用。这些实现类并非Duck.java的子
类型,而是专门的一组实现类,称之为"行为类"。由行为类而不是Duck.java的子类型来实现接口。这样,才能
保证变化的行为独立于不变的内容。
每种鸭子飞行和叫的方式不同,所以将这2部分独立出来:
[color=red][size=medium]飞的行为定义为接口[/size][/color]
实现了接口FlyBehavior的行为类FlyNoWay:
实现了接口FlyBehavior的行为类FlyWithWings:
[size=medium][color=red]将叫这种行为定义为接口[/color][/size]
实现了接口QuackBehavior 的一个行为类Quack :
实现了接口QuackBehavior 的一个行为类Squeak :
实现了接口QuackBehavior 的一个行为类MuteQuack :
[color=red][size=medium]下面是鸭子类([b]抽象类[/b]),正如上面,它已经将变化的部分抽象为接口FlyBehavior和QuackBehavior,剩下的是不变的部分swim和未实现的方法display;[/size][/color]
[color=red][size=medium]下面是一种鸭子具体实现,该鸭子将可变的部分通过实例化相应的实现类来初始化:
flyBehavior = new FlyWithWings(); //可变的部分
quackBehavior = new Quack(); //可变的部分
面向接口编程,将各种接口实现类的实例赋给接口变量,从而达到代码“复用性”;如果现实中这些实现还不能达到满足,我们可以增加对接口的实现类,比如鸭子不是用翅膀飞,那我们可以让它抱着火箭筒上天,随时增加和改变实现,直达满意位置,这又达到了代码的“灵活性”;不变的部分从Duck中继承过来[/size][/color]
测试:
输出:
1. 模式定义
把会变化的内容取出并封装起来,以便以后可以轻易地改动或扩充部分,而不影响不需要变化的其他部分;
2. 问题缘起
当涉及至代码维护时,为了复用目的而使用继承,结局并不完美。对父类的修改,会影响到子类型。在超类
中增加的方法,会导致子类型有该方法,甚至连那些不该具备该方法的子类型也无法免除。
(可重用但不灵活): 我们知道,继承在某种程度上可以实现"代码重用",但是父类(例如鸭子类Duck)的行为在子类型中是不断变化
的,让所有子类型都有这些行为是不恰当的。
(灵活但不可重用):我们可以将这些行为定义为接口,让Duck的各种子类型去实现,但接口不具有实现代码,所以实现接口无法达到代码复用。
这意味着,当我们需要修改某个行为,必须往下追踪并在每一个定义此行为的类中修改它,一不小心,会造成新的错误。
设计原则:把应用中变化的地方独立出来,不要和那些不需要变化的代码混在一起。这样代码变化引起的不
经意后果变少,系统变得更有弹性。
1) [color=red]分开变化的内容和不变的内容:[/color]
Duck类中的行为 fly(), quack(), 每个子类型可能有自己特有的表现,这就是所谓的变化的内容。
Duck类中的行为 swim() 每个子类型的表现均相同,这就是所谓不变的内容。
2) [color=red]整合变化的内容和不变的内容:[/color]
Duck.java将 fly()以及quack()的行为委拖给行为类处理(行为类就是一些实现了fly()接口的类)。
Duck.java不关心如何进行 fly()以及quack(), 这些细节交由具体的行为类完成。
我们将变化的内容从Duck()类中剥离出来单独定义形成接口以及一系列的实现类型。将变化的内容定义形
成接口可实现变化内容和不变内容的剥离。其实现类型可实现变化内容的重用。这些实现类并非Duck.java的子
类型,而是专门的一组实现类,称之为"行为类"。由行为类而不是Duck.java的子类型来实现接口。这样,才能
保证变化的行为独立于不变的内容。
每种鸭子飞行和叫的方式不同,所以将这2部分独立出来:
[color=red][size=medium]飞的行为定义为接口[/size][/color]
package com.wlh.strategy;
//变化的 fly() 行为定义形成的接口
public interface FlyBehavior {
void fly();
}
实现了接口FlyBehavior的行为类FlyNoWay:
package com.wlh.strategy;
//变化的 fly() 行为的实现类之二
public class FlyNoWay implements FlyBehavior {
public void fly() {
System.out.println("I can't fly.");
}
}
实现了接口FlyBehavior的行为类FlyWithWings:
package com.wlh.strategy;
//变化的 fly() 行为的实现类之一
public class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("I'm flying.");
}
}
[size=medium][color=red]将叫这种行为定义为接口[/color][/size]
package com.wlh.strategy;
//变化的 quack() 行为定义形成的接口
public interface QuackBehavior {
void quack();
}
实现了接口QuackBehavior 的一个行为类Quack :
package com.wlh.strategy;
//变化的 quack() 行为实现类之一
public class Quack implements QuackBehavior {
public void quack() {
System.out.println("Quack");
}
}
实现了接口QuackBehavior 的一个行为类Squeak :
package com.wlh.strategy;
//变化的 quack() 行为实现类之二
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println("Squeak.");
}
}
实现了接口QuackBehavior 的一个行为类MuteQuack :
package com.wlh.strategy;
//变化的 quack() 行为实现类之三
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println("<< Slience >>");
}
}
[color=red][size=medium]下面是鸭子类([b]抽象类[/b]),正如上面,它已经将变化的部分抽象为接口FlyBehavior和QuackBehavior,剩下的是不变的部分swim和未实现的方法display;[/size][/color]
package com.wlh.strategy;
public abstract class Duck {
// 将行为类声明为接口类型,降低对行为实现类型的依赖
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void performFly() {
// 不自行处理fly()行为,而是委拖给引用flyBehavior所指向的行为对象
flyBehavior.fly();
}
public void performQuack() {
quackBehavior.quack();
}
public void swim() {
System.out.println("All ducks float, even decoys.");
}
public abstract void display();
}
[color=red][size=medium]下面是一种鸭子具体实现,该鸭子将可变的部分通过实例化相应的实现类来初始化:
flyBehavior = new FlyWithWings(); //可变的部分
quackBehavior = new Quack(); //可变的部分
面向接口编程,将各种接口实现类的实例赋给接口变量,从而达到代码“复用性”;如果现实中这些实现还不能达到满足,我们可以增加对接口的实现类,比如鸭子不是用翅膀飞,那我们可以让它抱着火箭筒上天,随时增加和改变实现,直达满意位置,这又达到了代码的“灵活性”;不变的部分从Duck中继承过来[/size][/color]
package com.wlh.strategy;
public class MallardDuck extends Duck {
public MallardDuck() {
//面向接口编程,将各种实现的实例赋给接口变量,达到复用这些行为的实现
flyBehavior = new FlyWithWings(); //可变的部分
quackBehavior = new Quack(); //可变的部分
}
public void display() {//不变的部分
System.out.println("Green head.");
}
}
测试:
package com.wlh.strategy.test;
import com.wlh.strategy.Duck;
import com.wlh.strategy.MallardDuck;
public class DuckTest {
public static void main(String[] args) {
Duck duck=new MallardDuck();
duck.performFly();
duck.performQuack();
}
}
输出:
I'm flying.
Quack