策略模式（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();

	}

}

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