策略模式（headfirst设计模式学习笔记）

鸭子的行为被封装 进入一组类中，能够轻易的扩展和改变。假设须要能够执行时改变行为！

策略模式定义了算法族。分别封装起来。让他们能够相互替换，此模式让算法的变化独立于使用算法的客户。

继承，相似之处用继承，假如如干个功能点须要改动，代码难以维护，

原始代码

public  class Duck {
//鸭子描写叙述
public  void dispaly(){
System.out.println("描写叙述");
}

//鸭子叫
public void quack(){
System.out.println("会叫");
}

}

public class MallarDuck extends Duck{

public static void main(String[] args)  {
Duck duck=new Duck();
duck.dispaly();
duck.fly();
duck.quack();
}
}

假如Duck要加入新的行为鸭子飞，那代码难以维护，比方有的鸭子会飞有的不会飞。

假如继承或者实现接口，这二种都依赖于实现，我们会被绑的死死的，没有办法更改很多其它行为。

接口，针对接口编程，而不是针对实现编程，须要改动干个功能点使用接口，实现方式灵活多变。

更改后代码：

package com.base;

import com.interfaces.FlyBehavior;
import com.interfaces.QuackBehavior;
/**
* 将大功能点分为接口小模块。接口为了小功能点有弹性，
* @author Hadoop
*
*/
public abstract class Duck {
protected FlyBehavior flyBehavior;
protected QuackBehavior quackBehavior;

public void setFlyBehavior(FlyBehavior flyBehavior){
this.flyBehavior=flyBehavior;
}
public void QuackBehavior(QuackBehavior quackBehavior){
this.quackBehavior=quackBehavior;
}

public abstract void dispaly();//鸭子描写叙述

/**
* 托付给行为类
*/
public void performFly(){//鸭子飞
flyBehavior.fly();
}
public void performQuack(){//鸭子叫
quackBehavior.quack();
}

}

package com.interfaces;

/**
* 行为类（飞）
* @author Hadoop
*
*/
public interface FlyBehavior {
void fly();
}

package com.interfaces;

/**
* 鸭子叫
* @author Hadoop
*
*/

public interface QuackBehavior {
void quack();
}

package com.interfaces.impl;

import com.interfaces.FlyBehavior;

public class FlyNoWay implements FlyBehavior {

public void fly() {
System.out.println("鸭子不会飞行");
}

}

package com.interfaces.impl;

import com.interfaces.FlyBehavior;

public class FlyRocketPowered implements FlyBehavior {

public void fly() {
// TODO Auto-generated method stub
System.out.println("助力器");
}

}

package com.interfaces.impl;

import com.interfaces.FlyBehavior;

public class FlyWithWings implements FlyBehavior {

public void fly() {
System.out.println("鸭子飞行");
}

}

package com.interfaces.impl;

import com.interfaces.QuackBehavior;

public class Quack implements QuackBehavior {

public void quack() {
// TODO Auto-generated method stub
System.out.println("橡皮鸭子叫");
}

}

package com.interfaces.impl;

import com.interfaces.QuackBehavior;

public class Squack implements QuackBehavior {

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

}

详细鸭子

package com;

import com.base.Duck;
import com.interfaces.impl.FlyNoWay;
import com.interfaces.impl.FlyWithWings;
import com.interfaces.impl.Quack;

public class MallarDuck extends Duck{
public MallarDuck(){
quackBehavior=new Quack();
flyBehavior=new FlyNoWay();
}

public void dispaly() {
System.out.println("描写叙述");
}
}

import java.io.IOException;

import com.MallarDuck;
import com.interfaces.impl.FlyRocketPowered;

public class test {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
MallarDuck mallarDuck=new MallarDuck();
mallarDuck.dispaly();
mallarDuck.setFlyBehavior(new FlyRocketPowered());
mallarDuck.performFly();
mallarDuck.performQuack();

}

}

设计原则：多用组合，少用继承组合建立系统有非常大弹性，不仅能够将算法分类，并且能够动态的改变行为。 仅仅要组合行为对象符合正确的接口标本就可以。