设计模式之策略模式strategyPattern

设计模式之策略模式

设计模式：1.可变的与不可变的分开。2.针对接口编程

1：可变与不可变分开，不分开会怎么样？继承后要将每一个方法都重新实现？

2：接口可以作为一个标识符，比如一些空接口的存在，而且接口可以多实现

什么是策略模式呢：

它定义了算法族，分别封装，让它们之间可以相互代替，此模式让算法的变化独立于使用算法的客户！

系统的改变是我们所害怕的，但是由于策略模式的存在，我们可以动态或者随意的更换算法，从而不必害怕系统改变了。

/*我们要实现的类从这个鸭子大类继承过去，各种类别的鸭子~*/
/*我们将固定的与可变的分开，固定的在这里完成，有各种具体形式的可变的从接口的引用实现，而display这种可以可变而且没有形式则也在这里实现*/
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("所有的鸭子都会游泳");
 }
}

/*叫这个行为的接口*/
public interface QuackBehavior {
 
 public void quack();
 
}

/*飞这个行为的接口*/
public interface FlyBehavior {

 public void fly();

}

/*飞的算法族*/
public class FlyWithWings implements FlyBehavior{

 public void fly() {
  // TODO Auto-generated method stub
  System.out.println("l'm flying!");
 }

}

/*飞的算法族*/
public class FlyNoWay implements FlyBehavior{

 public void fly() {
  // TODO Auto-generated method stub
  System.out.println("I can't fly");
 }

}

public class Quack implements QuackBehavior{

 public void quack() {
  // TODO Auto-generated method stub
  System.out.println("Quack");
 }

}

/*叫的算法族，也就是各个行为的具体化，这就是变得部分*/
public class MuteQuack implements QuackBehavior{

 public void quack() {
  // TODO Auto-generated method stub
  System.out.println("<< silence >>");
 }

}

/*好的，这是我们第一个要实现的类，我们从继承和引用实现它的各个方法吧*/
public class Duck1 extends Duck{

 public Duck1(){
  quackbehavior = new Quack();
  flybehavior = new FlyWithWings();
 }
 
 public void display() {
  // TODO Auto-generated method stub
  System.out.println("the first duck");
 }

}

/*做个测试*/
public class testDuck{

 public static void main(String[] args) {
  Duck test = new Duck1();
  test.performFly();
  test.performQuack();
  test.display();
  test.swim();
 }
}

l'm flying!
Quack
the first duck
所有的鸭子都会游泳

下面我们要动态的设定行为了：

/*在Duck类中增加这么两个方法，我们就能动态的改变行为了*/

 public void setFlyBehavior(FlyBehavior fb){
  flybehavior = fb;
 }
 
 public void setQuackBehavior(QuackBehavior qb){
  quackbehavior = qb;
 }

/*增加一个模型鸭类*/
public class modelDuck extends Duck{

 public modelDuck(){
  flybehavior = new FlyNoWay();
  quackbehavior = new MuteQuack();
 }
 
 public void display() {
  // TODO Auto-generated method stub
  System.out.println("a model duck");
 }
 
}

/*增加一个新的飞行算法*/
public class FlyRocketPowered implements FlyBehavior{
 
 public void fly() {
  // TODO Auto-generated method stub
  System.out.println("i'm flying with a rocket~");
 }

}

  Duck modelduack = new modelDuck();
  modelduack.performFly();
  modelduack.setFlyBehavior(new FlyRocketPowered());
  modelduack.performFly();

/*于是模型鸭就从不会飞变成了依靠火箭飞行了*/

I can't fly
i'm flying with a rocket~

这正是策略模式给我们带来的好处啊，将不可变与固定形式的可变算法分开，我们甚至可以在运行时更换实现