package net.dp.strategy;

import net.dp.strategy.fly.FlyBehavior;
import net.dp.strategy.quack.QuackBehavior;

/**
* 策略者模式 鸭子父类
* @author Administrator
*
*/
public abstract class Duck {
//鸭子有可能具备飞行行为和叫喊行为 但是具体的行为不知道 所以父类中使用了这两个接口作为成员变量 由子类继承 再具体确定如何飞行和叫喊
//这个时候就需要接口来体现了。。并且接口有特定的实现类 由子类继承
protected FlyBehavior flyBehavior;
protected QuackBehavior quackBehavior;

//这个已经确定鸭子都具备的行为 所以直接使用抽象方法即可。。
public abstract void display();

/*
* 具体如何飞
*/
public void performFly(){
flyBehavior.fly();
}

/*
* 具体如何叫
*/
public void performQuack(){
quackBehavior.quack();
}

/*
* 鸭子都会游泳 所以已经确定了
*/
public void swim(){
System.out.println("All ducks float, even decoys!");
}

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

public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}

package net.dp.strategy;

import net.dp.strategy.fly.FlyNoWay;
import net.dp.strategy.fly.FlyWithWings;
import net.dp.strategy.quack.MuteQuack;
import net.dp.strategy.quack.Squeak;

public class ADuck extends Duck {
public ADuck() {
flyBehavior = new FlyWithWings();
quackBehavior = new Squeak();
}

public void display() {
System.out.println("I‘m a duck model.");
}

public void changeBehavior() {
setFlyBehavior(new FlyNoWay());
setQuackBehavior(new MuteQuack());
}

public static void main(String[] args) {
ADuck aDuck = new ADuck();
aDuck.display();
aDuck.swim();
aDuck.performFly();
aDuck.performQuack();
aDuck.changeBehavior();
aDuck.performFly();
aDuck.performQuack();
}
}

package net.dp.strategy;

import net.dp.strategy.fly.FlyWithWings;
import net.dp.strategy.quack.MuteQuack;

public class MyDuck extends Duck{

@Override
public void display() {
System.out.println("I am mcdola Duck");
}
/*
* 这是一只会飞但不能叫的鸭子
*/
public MyDuck()
{
flyBehavior=new FlyWithWings();
quackBehavior=new MuteQuack();
}


public static void main(String[] args) {
MyDuck md=new MyDuck();
md.display();
md.performFly();
md.performQuack();
}
}

package net.dp.strategy.fly;

/**
* 飞行行为接口
* @author Administrator
*
*/
public interface FlyBehavior {
void fly();
}

package net.dp.strategy.fly;

/**
* 飞行的一个特定实现类：无法飞行
* @author Administrator
*
*/
public class FlyNoWay implements FlyBehavior{
public void fly(){
System.out.println("I can‘t fly.");
}
}

package net.dp.strategy.fly;

/**
* 特定的飞行实现类 有翅膀的飞行 实现FlyBehavior接口 不然某个鸭子类直接实现接口的原因是代码无法复用
* @author Administrator
*
*/
public class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("I‘m flying and with wings!");
}
}

package net.dp.strategy.quack;

/*
* 没有叫喊
*/
public class MuteQuack implements QuackBehavior{
public void quack(){
System.out.println("<<Silence>>");
}
}

package net.dp.strategy.quack;
/**
* 普通叫喊实现类
* @author Administrator
*
*/
public class Quack implements QuackBehavior{

public void quack(){
System.out.println("quack");
}
}

package net.dp.strategy.quack;

/**
* 叫喊接口
* @author Administrator
*
*/
public interface QuackBehavior {
void quack();
}

package net.dp.strategy.quack;

/*
* 另一种叫喊方式
*/
public class Squeak implements QuackBehavior{
public void quack(){
System.out.println("Squeak");
}
}

设计模式之策略者设计模式