java 策略模式

策略模式：

//鸭子

public interface Duck
{
public void sound();

public void move();

}

//小红鸭

public class redDuck extends Duck
{

public void sound()
{
system.out.println("小红鸭叫");
}

public void move()
{
system.out.println("小红鸭移动");
}

}

//小黑鸭

public class blackDuck extends Duck
{

public void sound()
{
system.out.println("小黑鸭叫");
}

public void move()
{
system.out.println("小黑鸭移动");
}

}

//假如你现在有一只小飞鸭子，有个新功能会飞，怎么把这个功能加进去。

继承------

直接在父类定义 fly()方法，其子类就会有，弊端是：今后有一只玩具鸭子，根本不能飞 因此不能用继承。

抽象类-----

会让子类强制覆盖这个方法，没覆盖就会报错， 弊端是：如果不需的话，会有大量的代码冗余

怎么写出能够灵活一点的代码，能够比较自由的扩展功能：

当出现这个问题的时候，很自然的会想到能不能定义一个类，这个类有一个fly()方法

当某个类需要飞行时候，引入具有飞行方法的类到某个类里面，

顺着这个思路，我们会想到，如果单单只是需要飞行，就定义一个类，这样会出现这样的问题，因为飞行是一个功能，

实现飞行的方式却有很多，因此我们应该考虑到把这个类编写成接口，而不是具体的实现类（这就是面像接口编程）

面向接口编程的优点是，接口只定于规则，比如飞，走，吃，但是不定义实现，比如你坐飞机飞，坐火箭飞，。。。都行

这就是面像接口编程）接口只负责定义规则，各种该规则的具体实现交给该接口的实现类

现在定义具有飞行的fly()功能，的接口

public interface Canfly
{

void fly();

}

定义一个用于使用策略的类

public class UserStrategy
{

private Canfly canfly
public UserStrategy(Canfly canfly)
{

this.canfly = canfly;

}

public void fly()
{

system.out.println("小飞鸭飞");

}

}

 

//定义小飞鸭

public class FlyDuck extends Duck implememnts Canfly
{

Private UserStrategy userStrategy;

public Duck(Duck duck)
{

this.duck=duck;

}

public void sound()
{
system.out.println("小飞鸭叫");
}

public void move()
{
system.out.println("小飞鸭移动");
}

}

public class DemoTest
{
public static void main(String [] args)
{

Canfly flyduck = new Duck(new FlyDuck);

flyduck.fly();

}
}