策略模式

1、编写鸭子项目

1）有各种鸭子（比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等）。

2）显示鸭子的信息。

【传统设计方案】

写一个Duck抽象类，让野鸭、水鸭等类去继承此Duck类。

public abstract class Duck {
    public Duck() {   
    }
    
    public abstract void display(); // 显示鸭子信息
    
    public void quack() {
        System.out.println("鸭子嘎嘎嘎");
    }
    
    public void swim() {
        System.out.println("鸭子会游泳");
    }
    
    public void fly() {
        System.out.println("鸭子会飞");
    }
}

public class WildDuck extends Duck {
    @Override
    public void display() {
        System.out.println("这是野鸭");
    }
}

public class PekingDuck extends Duck {
    @Override
    public void display() {
        System.out.println("北京鸭");
    }
    
    // 因为北京鸭不能飞行，因此需要重写fly
    @Override
    public void fly() {
        System.out.println("北京鸭不能飞翔");
    }
}

public class ToyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("玩具鸭");
    }
    
    public void quack() {
        System.out.println("玩具鸭不能叫");
    }
    public void swim() {
        System.out.println("玩具鸭不会游泳");
    }
    public void fly() {
        System.out.println("玩具鸭不会飞翔");
    }
}

【传统方式的问题分析】

1）其他鸭子都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。

2）上面说的问题是继承带来的问题，对类的局部改动，尤其父类的局部改动，会影响其他部分，会有溢出效应。

3）为例改进此问题，我们可以通过覆盖fly方法来解决，覆盖解决方式。

4）问题又来了，如果我们有一个玩具鸭子，这样就需要覆盖所有的方法。解决思路就是使用策略模式（strategy pattern）。

2、策略模式的基本介绍

1）策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

2）这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来。第二、针对接口编程而不是具体类（定义策略接口）。第三、多用组合/聚合，少用继承（客户通过组合方式使用策略）。

3、结构

策略模式的主要角色如下：

抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。
环境（Context）类：持有一个策略类的引用，最终给客户端调用。

4、应用实例代码实现

// 抽象策略类
public interface FlyBehavior {
    void fly(); // 子类具体实现
}

// 具体策略类
public class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术高超");
    }
}
public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术差的一批");
    }
}
public class NoFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

public abstract class Duck {
    FlyBehavior flyBehavior;
    public Duck() {
    }
    
    public abstract void display();
    
    public void fly() {
        flyBehavior.fly();
    }
}

public class WildDuck extends Duck {
    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }
    
    public void display() {
        System.out.println("这是野鸭");
    }
}

public class PekingDuck extends Duck {
    public PekingDuck() {
        flyBehavior = new NoFlyBehavior();
    }
    
    @Override
    public void display() {
        System.out.println("北京鸭");
    }
}

public class ToyDuck extends Duck {
    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
    }
    
    @Override
    public void display() {
        System.out.println("玩具鸭");
    }
}

public class Client {
    public static void main(String[] args) {
        Duck wd = new WildDuck();
        wd.fly();
    }
}

5、策略模式在JDK-Arrays源码分析

1）JDK的Arrays的Comparator就使用了策略模式。

2）代码分析

public class Strategy {
    public static void main(String[] args) {
        Integer[] data = {9, 1, 2, 8, 4, 3};
        Comparator<Integer> comparator = new Comparator<>() {
            public int compare(Integer o1, Integer o2) {
                if(o1 > o2) {
                    return 1;
                }else {
                    return -1;
                }
            }
        }
        
        Arrays.sort(data, comparator);
        System.out.println(Arrays.toString(data));
    }
}