策略模式

实践代码体验：1~3版（使用设计模式让代码更加容易扩展，降低耦合，抽象出模板）

**
 * @author xiaokai
 *
 * 1. 鸭子的游戏：基类  quack-叫 swim-游泳 display-外观
 * 2. 现在要让鸭子能飞  Duck加个fly 但是橡皮鸭（RubberDuck）不会飞 使用将fly方法覆盖,根quack一样
 *    现在又出现一个 (WoodDuck)木头鸭 不会叫 不会飞
 *
 * 利用继承提供的Duck（鸭子）的行为会导致哪些缺点？
 *
 *   （1）代码在多个子类中重复
 *
 *   （2）很难知道所有鸭子的全部行为
 *
 *   （3）运行时的行为不容易改变
 *
 *   （4）改变会牵一发动全身，造成其他鸭子的不想要的改变
 *
 *  3. 现在该如何设计，鸭子的行为在子类不停的变化？
 * 
 *    现在把fly的行为 和 叫的行为 定义成接口，从 duck中提取出来，有需要的鸭子实现它，没有的不实现？
 * 
 *   （1） Java接口不具备实现，因此你要修改某个行为，你需要追踪到每个子类去修改代码，达不到复用代码的作用
 *     (2)    鸭子不应该与变化的东西是继承关系,接口是一种特殊继承，应该是有一个
 *
 *  【设计原则】
 *
 *   分开变化和不变化的部分
 *
 *   针对接口编程，而不是针对实现编程
 *
 *  4.根据设计原则，推出第二版鸭子？
 */
public abstract class Duck {

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

    public void swim(){
        System.out.println("游泳");
    }

    //每种鸭子的外观不同
    public  abstract void display();


    public void fly(){
        System.out.println("飞翔");
    }
}

/**
 * @author xiaokai
 */
public class GreenDuck extends Duck {

    @Override
    public void display() {
        System.out.println("我是绿头鸭");
    }
}

package com.xiaokai.one_part_1.extendClass;

import com.xiaokai.one_part_1.superClass.Duck;

/**
 * @author xiaokai
 */
public class RedDuck extends Duck {

    @Override
    public void display() {
        System.out.println("我是红头鸭");
    }
}

/**
 * @author xiaokai
 * 橡皮鸭（新需求，不会叫，吱吱叫，使用继承必须强迫你去检查新的需求，父类是否满足，不满足，需要覆盖实现，这样很烦）
 */
public class RubberDuck extends Duck {

    @Override
    public void display() {
        System.out.println("我是橡皮鸭，我不会飞");
    }

    @Override
    public void quack() {
        System.out.println("吱吱叫");
    }

    @Override
    public void fly() {
        System.out.println("我不会叫");
    }
}

第三版：

package com.xiaokai.one_part_2.superClass;

import com.xiaokai.one_part_2.Behavior.FlyBehavior;
import com.xiaokai.one_part_2.Behavior.QuackBehavior;

/**
 * @author xiaokai
 * 1.鸭子不会负责实现行为接口，以前是通过继承和覆盖或者是鸭子实现接口，将代码在子类实现，绑定的死死的。
 *   （委托）现在是具体实现交由 FlyBehavior 和 QuackBehavior，这样有新鸭子来，鸭子代码是不变的，只要扩展新的接口，实现子类就可以，完美
 *
 * 2.第三版：给委托加set方法，将子类的面对具体实现去掉，动态的改变鸭子的飞行行为
 *
 * 分清：有一个 是一个 实现
 *
 * 【设计原则】
 *
 *  多用组合(有一个)，少用继承(是一个 实现)
 *
 * 3.组合的优点：在运行时动态的改变行为，组合对像符合标准的接口即可
 *
 * 4.第一个设计模式：策略模式(定义了算法族，分别封装起来 flyBehavior quackBehavior)
 *    使用策略模式实现鸭子的行为，鸭子的行为被封装到一组类中，鸭子的行为能为轻易的扩展与改变
 */
public abstract class Duck {

    FlyBehavior flyBehavior;

    QuackBehavior quackBehavior;

    public void swim(){
        System.out.println("游泳");
    }

    //每种鸭子的外观不同
    public  abstract void display();


    public void performFly(){

        flyBehavior.fly();//将飞的行为委托出去了
    }


    public void performQuack(){

        quackBehavior.quack();
    }


    //将子类中的具体实现代码改变
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

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

//飞的接口
public interface FlyBehavior {

    void fly();
}

public class CanFly implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("我会飞");
    }
}

public class NoFly implements FlyBehavior {
	
	@Override
    public void fly() {
        System.out.println("我不会飞");
    }
}

//叫的接口
public interface QuackBehavior {

    void quack();
}

public class NoQuack implements QuackBehavior{
    @Override
    public void quack() {
        System.out.println("不会叫");
    }
}

又来了一个木头鸭子，不会飞，也不会叫，使用第三版体验策略模式的方便之处？
public class WoodDuck extends Duck {

    @Override
    public void display() {
        System.out.println("我是木头鸭子");
    }

}

 public static void main( String[] args )
    {
        //第二版
        //Duck greenDuck = new GreenDuck();
        //greenDuck.performFly();
        
        
        Duck rubberDuck = new RubberDuck();
        rubberDuck.setFlyBehavior(new NoFly());
        rubberDuck.performFly();
        
        //第三版  运行时动态绑定(JVM)  木头鸭
        Duck woodDuck = new WoodDuck();
        woodDuck.setFlyBehavior(new NoFly());
        woodDuck.setQuackBehavior(new NoQuack());
        woodDuck.performFly();
        woodDuck.performQuack();
    }

自我总结：抽象出一套模板(Duck)不变的东西，模板里面留有规范的插槽（FlyBehavior QuackBehavior），运行时将符合插槽的具体实现组装进去，实现功能不同的产品
大白话：CPU主板上面有很多插槽，想要不同规格的CPU主板，对应的插槽中插入不同的部件(内存条1G 2G …)