Java设计模式之策略模式

策略模式原则：封装变化部分；多用组合少用继承；面向接口而非接口实现编程。

1.提取变化部分，封装成接口。

public interface Fly {

    void fly();
}

public interface Quack {

    void quack();
}

2.实现接口

public class GoodFly implements Fly {

    @Override
    public void fly() {
        System.out.println("good fly");
        
    }
}

public class NoFly implements Fly {

    @Override
    public void fly() {
        System.out.println("no fly");
    }
}

public class GoodQuack implements Quack {

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

public class NoQuack implements Quack {
    
    @Override
    public void quack() {
        System.out.println("no quack");    
    }
}

3.将接口引入超类，将角色共同部分封装再超类里面，同时在超类设置接口的set方法，这样在子类实现的时候可以通过设置的方法来改变接口方法对应的值。

public abstract class Duck {
     
    Fly mfly;
    Quack mquack;
    
    public Duck(){
        
    }
    
    public void behavior(){
        mfly.fly();
        mquack.quack();
    }
    
    public abstract void display();

    public void setFly(Fly fly) {
        this.mfly = fly;
    }

    public void setQuack(Quack quack) {
        this.mquack = quack;
    }
        
}

4.子类实现超类，子类可以通过构造函数来引入接口，不需要引入超类所有的接口，只需要引入自身需要的就好。

public class GreenDuck extends Duck{

    public GreenDuck(){
        mfly = new GoodFly();
        mquack = new GoodQuack();
    }
    
    @Override
    public void display() {
        System.out.println("green");    
    }

}

public class RedDuck extends Duck{
    
    public RedDuck(){
        mfly = new NoFly();
        mquack = new NoQuack();
    }
    
    @Override
    public void display() {
        System.out.println("red");        
    }

}

5.编写主函数，通过set方法来重新给方法设置值。

public class Operation {

    public static void main(String[] args) {
        Duck mGreenDuck = new GreenDuck();
        Duck mRedDuck = new RedDuck();
        
        mGreenDuck.display();
        mGreenDuck.behavior();
        
        mRedDuck.display();
        mRedDuck.behavior();
        
        mGreenDuck.display();
        mGreenDuck.setFly(new NoFly());
        mGreenDuck.setQuack(new NoQuack());
        mGreenDuck.behavior();
        
    }
}

6.运行结果

green
good fly
good quack
red
no fly
no quack
green
no fly
no quack

通过上述例子可以看出，策略模式的核心主要是通过组合的方式来降低角色与方法之间的耦合性，同时也提高了代码的复用效率。