策略模式:定义了算法族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化独立于使用算法的客户。
设计原则:
(1)找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起
(2)针对接口编程,而不是针对实现编程
(3)多用组合,少用继承
使用组合建立的系统具有很大的弹性,不仅可将算法族封装成类,更可以“在运行时动态的改变行为”,只要组合的行为对象符合正确的接口标准即可。
Demo:
package 策略模式;
/**
* 鸭子现在会将飞行和呱呱叫的动作“委托”别人处理,而不是使用定义在Duck类内的呱呱叫和飞行方法
* */
public abstract class Duck {
/**
* 首先,在Duck类中加入两个实例变量,分别为flyBehavior,quackBehavior,声明为接口类型,
* 每个鸭子对象都会动态的设置这些变量,以在运行时引用正确的行为类型。
*
* 每只鸭子都会实现FlyBehavior和QuackBehavior接口对象
* */
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
// TODO Auto-generated constructor stub
}
public abstract void dispaly();
/**
* 鸭子对象不会亲自处理飞行和呱呱叫行为,而是委托给flyBehavior和quackBehavior引用的对象
* */
public void performFly() {
flyBehavior.fly();
}
public void performQuack() {
quackBehavior.quack();
}
public void swim() {
System.out.println("All ");
}
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}
}
package 策略模式;
/**
* 所有飞行类都必须实现的接口
* */
public interface FlyBehavior {
public void fly();
}
package 策略模式;
/**
* 所有叫声类都必须实现的接口
* */
public interface QuackBehavior {
void quack();
}
package 策略模式;
/**
* 这是飞行类的实现。给不会飞行的鸭子使用
* */
public class FlyNoWay implements FlyBehavior{
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("我不能飞");
}
}
package 策略模式;
/**
* 火箭飞行方式
* */
public class FlyRocketProwered implements FlyBehavior {
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("我能用火箭飞行");
}
}
package 策略模式;
/**
* 这是飞行类的实现。给会飞行的鸭子使用
* */
public class FlyWithWings implements FlyBehavior{
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("我能飞");
}
}
package 策略模式;
/**
* 叫声类实现
* */
public class Quack implements QuackBehavior {
@Override
public void quack() {
// TODO Auto-generated method stub
System.out.println("呱呱叫");
}
}
package 策略模式;
/**
* 叫声类实现
* */
public class Squeak implements QuackBehavior{
@Override
public void quack() {
// TODO Auto-generated method stub
System.out.println("吱吱叫");
}
}
package 策略模式;
/**
* 叫声类实现
* */
public class MuteQuack implements QuackBehavior{
@Override
public void quack() {
// TODO Auto-generated method stub
System.out.println("不会叫");
}
}
package 策略模式;
/**
* 绿头鸭
*
*
* */
public class MallardDuck extends Duck{
/**
* 绿头鸭使用Quack类处理呱呱叫,所以当performQuack()被调用时,叫的职责委托给Quack对象,而我们将得到真正的呱呱叫。
* */
public MallardDuck() {
quackBehavior = new Quack();
flyBehavior = new FlyWithWings();
}
@Override
public void dispaly() {
// TODO Auto-generated method stub
System.out.println("MallardDuck");
}
}
package 策略模式;
/**
* 模型鸭
* */
public class ModelDuck extends Duck {
public ModelDuck() {
// TODO Auto-generated constructor stub
flyBehavior = new FlyNoWay();
quackBehavior = new Squeak();
}
@Override
public void dispaly() {
// TODO Auto-generated method stub
System.out.println("我是模型鸭");
}
}
package 策略模式;
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
/**
* 这会调用MallardDuck()继承来的方法,进而委托给给对象的QuackBehavior和FlyBehavior对象处理
* */
mallard.performQuack();
mallard.performFly();
System.out.println("------------------------");
/**
* 模型鸭
* */
Duck model = new ModelDuck();
model.performQuack();
model.performFly();
/**
* 设置不同的飞行方式
* */
model.setFlyBehavior(new FlyRocketProwered());
model.performFly();
}
}