策略模式

实现鸭子的各自行为，显示自己的信息，叫，游泳，飞等。
传统实现如下：

image.png

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("玩具鸭不会飞翔~~~");
    }
}

传统实现的分析：所有鸭子具体类都继承抽象类Duck类，所以fly让所有鸭子都会飞了，这不符合情况，这个问题是继承带来的问题，对父类的局部操作对影响到其他类，为了改进这个问题，我们需要在具体类上重写这个方法，但是问题又来了，如果我们有一个玩具鸭，那么我们需要重写Duck的所有方法，我们可以使用策略模式来解决这个问题。

• 策略模式原理图

  
  image.png
  

  这里只处理fly的解决，其他类似。

public abstract class Duck {
    //属性, 策略接口
    FlyBehavior flyBehavior;
    //其它属性<->策略接口
    QuackBehavior quackBehavior;
    
    public Duck() {}

    public abstract void display();//显示鸭子信息
    
    public void fly() {
        //改进
        if(flyBehavior != null) {
            flyBehavior.fly();
        }
    }
    
    public void quack() {
        // 这里也可以同样改进
        System.out.println("鸭子嘎嘎叫~~");
    }
    
    public void swim() {
        System.out.println("鸭子会游泳~~");
    }

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

public interface FlyBehavior {
    void fly(); // 子类具体实现
}
public interface QuackBehavior {
    void quack();//子类实现
}
public class BadFlyBehavior implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println(" 飞翔技术一般 ");
    }
}
public class GoodFlyBehavior implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println(" 飞翔技术高超 ~~~");
    }
}
public class NoFlyBehavior implements FlyBehavior{

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

public class WildDuck extends Duck {
    //构造器，传入FlyBehavor 的对象
    public  WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }
    
    @Override
    public void display() {
        System.out.println(" 这是野鸭 ");
    }
}
public class PekingDuck extends Duck {
    //假如北京鸭可以飞翔，但是飞翔技术一般
    public PekingDuck() {
        flyBehavior = new BadFlyBehavior();
        
    }
    
    @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 void quack() {
        System.out.println("玩具鸭不能叫~~");
    }
    
    public void swim() {
        System.out.println("玩具鸭不会游泳~~");
    }
}

    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.fly();//
        
        ToyDuck toyDuck = new ToyDuck();
        toyDuck.fly();
        
        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.fly();
        
        //动态改变某个对象的行为, 北京鸭 不能飞
        pekingDuck.setFlyBehavior(new NoFlyBehavior());
        System.out.println("北京鸭的实际飞翔能力");
        pekingDuck.fly();
    }
}

image.png

策略模式源码具体使用

Arrays.sort(T[] a, Comparator<? super T> c);

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {//如果未提供具体的策略对象，那么使用默认的策略来处理
            sort(a);
        } else {//否则使用提供的策略来处理
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    public static void main(String[] args) {
        //数组
        Integer[] data = { 9, 1, 2, 8, 4, 3 };
        // 实现降序排序，返回-1放左边，1放右边，0保持不变
        
        // 1. 实现了 Comparator 接口（策略接口） , 匿名类 对象 new Comparator<Integer>(){..}
        // 2. 对象 new Comparator<Integer>(){..} 就是实现了 策略接口 的对象
        // 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            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)); // 降序排序
    }

策略模式注意事项和细节

• 提供了可以替换继承关系的方法，将具体策略封装在独立的Strategy中使得开发者可以独立于其Context改变它，其策略易于切换，扩展等。
• 策略模式的重点是分析模块中的变化部分和不变部分
• 需要注意的是：每添加一个策略就要增加一系列类，当策略过多的时候会导致类数目庞大。