java的23个设计模式学习笔记（策略模式）

上课老听老师讲各种模式，不是特别理解，今天来系统的学习一下
推荐书籍《设计模式》

策略模式

定义：分别封装行为接口，实现算法族、超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为算法的变化独立于算法的使用者。

使用场景

开始的需求：设计一个鸭子类有最基本的发出声音和游泳的功能
超类：

/**
 *策略模式，鸭子超类
 **/

public abstract class Duck {
    public  Duck(){
    }
    public void  Quack(){
        System.out.println("嘎嘎~");
    }
    public  abstract  void  display();
    private  void swim(){
        System.out.println("swimming");
    }
}

子类：

/**
 * 绿头鸭继承超类
 **/

public class GreenHeadDuck extends Duck {
    @Override
    public void display() {
        System.out.println("我是绿头鸭");
    }
}
/**
 * 红头鸭继承超类
 **/

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

项目新需求，应对新需求看设计的可扩展性
1）添加会飞的鸭子

解决方案：
1.面向对象的思维里的继承方式解决方案是：

public abstract class Duck {
    ...
    public void fly(){
        System.out.println("fly");
    }
}

问题来了，这个fly让所有子类都会飞了，但是北京烤鸭不会飞啊，这是不科学的。
继承的问题：对类的局部改动，尤其是超类的局部改动，会影响其他部分。影响会有溢出效应

2.继续尝试试用面向对象原理来解决，覆盖：

public class GreenHeadDuck extends Duck {
    ...
    public void fly(){
        System.out.println("no fly~~");
    }
}

但是问题又来了，如果子类有几十种，每种都要覆盖掉，工作量很大而且重复劳动。
3.没关系，我们继续填坑，那就将fly（）方法写成抽象类，让子类来实现。
问题又来了，如果有十几个都是同样的飞方法呢？降低了代码的复用性。

（2）又有新需求，石头鸭子，不会叫不会游泳。。。
**超类挖的一个坑，每个子类都要来填，增加工作量，复杂度o(n^2),不是好的设计方式

用策略模式来新需求解决

需要新的设计方式，应对项目的扩展性，降低复杂度：
1）分析项目变化与不变部分，提取变化部分，抽象成接口+实现
2）鸭子哪些功能是会根绝新需求变化的？叫声、飞行…

1.接口

1)public interface FlyBehavior {
    void fly();
}
2)public interface QuackBehavior {
    void quack();
}

行为底下可以有各种行为类实现它，只要实现接口就好，形成行为族


好处：新增行为简单，行为类更好的复用，组合更方便。既有继承带来的复用好用，没有挖坑。

重新设计模拟鸭子项目

/**
*超类
**/
public abstract class Duck {
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public  Duck(){
    }
    public void  Quack(){
        quackBehavior.quack();
    }
    public void fly(){
        flyBehavior.fly();
    }
    public  abstract  void  display();
}

/**
*绿头鸭子类
**/
public class GreenHeadDuck extends Duck {
    public GreenHeadDuck(){
        flyBehavior = new GoodFlyBehavior() ;
        quackBehavior =new BadQuackBehavior() ;
        }
    }
    @Override
    public void display() {
        System.out.println("我是绿头鸭");
    }
}

动态改变行为：
在超类中加入两个set方法

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

main函数：

public static void main (String[] args){
        Duck greenHeagDuck = new GreenHeadDuck();
        Duck redHeadDuck = new RedHeadDuck();
        greenHeagDuck.setFlyBehavior(new NoQuackBehavior());
        greenHeagDuck.setQuackBehavior(new NoQuackBehavior());
    }

用超类做对象类型：屏蔽了子类中的具体实现，只调用超类中的方法方式，不管子类怎么具体实现。不用考虑上层的差别性。

策略模式的注意点

1.分析项目中变化部分与不变部分
2.多用组合少用继承；用行为类组合，而不是行为的继承。更有弹性。
3.设计模式有没有相应的库直接使用？有些库或框架本身就是用某种设计模式设计