Java设计模式之Java策略模式详解

什么是Java策略模式？

Java策略模式是一种行为型设计模式，它定义了算法族，即一组具有相同目的和不同实现的算法，让它们之间可以相互替换。这个模式让算法的变化独立于使用算法的客户端，从而实现算法行为的变化而无需更改使用算法的客户端。

Java策略模式的三个角色

Java策略模式一般涉及到如下三个角色：

1. Context 上下文对象：持有一个Strategy对象，并在其内部的某个方法中调用该对象的方法实现具体的算法行为。
2. Strategy 策略接口：封装具体的算法实现，提供一个执行算法的方法进行调用。
3. Concrete Strategy 具体策略：实现策略接口，定义具体的算法实现方法。

Java策略模式的优点

1. 策略模式可避免使用多重条件语句（if...else语句）。
2. 策略模式为算法实现提供了更具优化的更换方案，增强系统的灵活性和维护性。
3. 策略模式将一系列的算法封装成类独立于客户端进行独立修改和扩展。

Java策略模式的示例

下面举两个简单的Java策略模式的示例：

示例一：鸭子游戏

假设我们有一个鸭子游戏，游戏里有多种不同类型的鸭子，它们需要实现三个行为：游泳、飞行和叫声。

// 鸭子抽象类
public abstract class Duck {
    SwimBehavior swimBehavior;
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public void setSwimBehavior(SwimBehavior sb) {
        swimBehavior = sb;
    }

    public void setFlyBehavior(FlyBehavior fb) {
        flyBehavior = fb;
    }

    public void setQuackBehavior(QuackBehavior qb) {
        quackBehavior = qb;
    }

    public void swim() {
        swimBehavior.swim();
    }

    public void fly() {
        flyBehavior.fly();
    }

    public void quack() {
        quackBehavior.quack();
    }

    public abstract void display();
}

// 游泳行为接口
public interface SwimBehavior {
    void swim();
}

// 飞行行为接口
public interface FlyBehavior {
    void fly();
}

// 叫声行为接口
public interface QuackBehavior {
    void quack();
}

具体的鸭子类型分别实现抽象类Duck，并设置各自的游泳、飞行和叫声行为：

// 绿头鸭
public class MallarDuck extends Duck {
    public MallarDuck() {
        swimBehavior = new SwimWithSLippers();
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    @Override
    public void display() {
        System.out.println("MallarDuck");
    }
}

// 红头鸭
public class RedheadDuck extends Duck {
    public RedheadDuck() {
        swimBehavior = new SwimWithOutSLippers();
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    @Override
    public void display() {
        System.out.println("RedheadDuck");
    }
}

// 橡皮鸭
public class RubberDuck extends Duck {
    public RubberDuck() {
        swimBehavior = new SwimWithOutSLippers();
        flyBehavior = new NoFly();
        quackBehavior = new Squeak();
    }

    @Override
    public void display() {
        System.out.println("RubberDuck");
    }
}

// 诱饵鸭
public class DecoyDuck extends Duck {
    public DecoyDuck() {
        swimBehavior = new SwimWithOutSLippers();
        flyBehavior = new NoFly();
        quackBehavior = new MuteQuack();
    }

    @Override
    public void display() {
        System.out.println("DecoyDuck");
    }
}

游戏中不同的鸭子类型，根据其具体的行为进行配置：

public class DuckGame {
    public static void main(String[] args) {
        Duck mallarDuck = new MallarDuck();
        mallarDuck.swim();
        mallarDuck.fly();
        mallarDuck.quack();

        Duck rubberDuck = new RubberDuck();
        rubberDuck.swim();
        rubberDuck.fly();   // 诱饵鸭和橡皮鸭不能飞行，因此具体的策略实现为NoFly；
        rubberDuck.quack();
    }
}

在上述示例中，游戏中不同的鸭子类型根据具体的行为进行配置，并能够根据需要动态的配置每个鸭子的具体实现。

示例二：商城商品打折

假设我们有一个商城系统，对于不同价格区间的商品，需要根据具体的折扣策略进行优惠。

// 商品抽象类
public abstract class Goods {
    // 获取商品的价格
    public abstract double getPrice();

    // 获取打折后的价格
    public abstract double getDiscountPrice(DiscountStrategy discountStrategy);
}

// 折扣策略接口
public interface DiscountStrategy {
    double discount(double price);
}

// 新手客户策略
public class NewCustomerDiscount implements DiscountStrategy {
    @Override
    public double discount(double price) {
        System.out.println("新手客户打9折！");
        return price * 0.9;
    }
}

// 老客户策略
public class OldCustomerDiscount implements DiscountStrategy {
    @Override
    public double discount(double price) {
        System.out.println("老客户打8折！");
        return price * 0.8;
    }
}

// VIP客户策略
public class VIPCustomerDiscount implements DiscountStrategy {
    @Override
    public double discount(double price) {
        System.out.println("VIP客户打7折！");
        return price * 0.7;
    }
}

// 具体的商品实现类
public class GoodsImpl extends Goods {
    private double price;

    public GoodsImpl(double price) {
        this.price = price;
    }

    @Override
    public double getPrice() {
        return price;
    }

    @Override
    public double getDiscountPrice(DiscountStrategy discountStrategy) {
        return discountStrategy.discount(price);
    }
}

不同价格区间的商品根据打折策略进行打折，商城系统实现如下：

public class DiscountGame {
    public static void main(String[] args) {
        Goods goods1 = new GoodsImpl(100.0);
        double discountPrice1 = goods1.getDiscountPrice(new NewCustomerDiscount());
        System.out.println("物品1的打折后价格：" + discountPrice1);

        Goods goods2 = new GoodsImpl(500.0);
        double discountPrice2 = goods2.getDiscountPrice(new OldCustomerDiscount());
        System.out.println("物品2的打折后价格：" + discountPrice2);

        Goods goods3 = new GoodsImpl(1000.0);
        double discountPrice3 = goods3.getDiscountPrice(new VIPCustomerDiscount());
        System.out.println("物品3的打折后价格：" + discountPrice3);
    }
}

在上述示例中，不同价格区间的商品根据打折策略进行打折，商城系统具有完善的策略规定，并能够根据需要动态的配置不同的打折策略。