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

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

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

原始代码

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();

	}

}

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