策略模式的例子

这是一个使用策略模式的Java示例，其中定义了一个排序策略接口，以及三个实现了该接口的排序策略类：冒泡排序、快速排序和插入排序。这里假设我们已经实现了这三种排序算法：

import java.util.List;

// 策略接口
interface SortStrategy {
    void sort(List<Integer> numbers);
}

// 冒泡排序策略
class BubbleSortStrategy implements SortStrategy {
    public void sort(List<Integer> numbers) {
        // ...具体实现略
        System.out.println("Bubble sort");
    }
}

// 快速排序策略
class QuickSortStrategy implements SortStrategy {
    public void sort(List<Integer> numbers) {
        // ...具体实现略
        System.out.println("Quick sort");
    }
}

// 插入排序策略
class InsertionSortStrategy implements SortStrategy {
    public void sort(List<Integer> numbers) {
        // ...具体实现略
        System.out.println("Insertion sort");
    }
}

// 使用策略的上下文类
class Sorter {
    private SortStrategy strategy;

    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(List<Integer> numbers) {
        strategy.sort(numbers);
    }

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
}

我们可以通过Sorter类的setStrategy()方法轻松更改排序策略。以下是一个使用例子：

javaCopy codepublic class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);

        Sorter sorter = new Sorter(new BubbleSortStrategy());
        sorter.sort(numbers);

        sorter.setStrategy(new QuickSortStrategy());
        sorter.sort(numbers);

        sorter.setStrategy(new InsertionSortStrategy());
        sorter.sort(numbers);
    }
}

在这个例子中，我们先用冒泡排序对列表排序，然后切换到快速排序，最后切换到插入排序。

以下是一个使用策略模式来处理不同折扣策略的简单Java示例：

/ 策略接口
interface DiscountStrategy {
    double applyDiscount(double price);
}

// 对于新客户，可能没有折扣
class NewCustomerDiscountStrategy implements DiscountStrategy {
    public double applyDiscount(double price) {
        return price;
    }
}

// 对于常规客户，可能有10%的折扣
class RegularCustomerDiscountStrategy implements DiscountStrategy {
    public double applyDiscount(double price) {
        return price * 0.9;
    }
}

// 对于VIP客户，可能有20%的折扣
class VipCustomerDiscountStrategy implements DiscountStrategy {
    public double applyDiscount(double price) {
        return price * 0.8;
    }
}

// 使用策略的购物车类
class ShoppingCart {
    private DiscountStrategy discountStrategy;

    public ShoppingCart(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double checkout(double price) {
        return discountStrategy.applyDiscount(price);
    }

    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
}

在这个示例中，我们先使用新客户策略结账，然后切换到常规客户策略，最后切换到VIP客户策略。以下是使用示例：

javaCopy codepublic class Main {
    public static void main(String[] args) {
        double originalPrice = 100.0;

        ShoppingCart cart = new ShoppingCart(new NewCustomerDiscountStrategy());
        System.out.println("New customer: " + cart.checkout(originalPrice));

        cart.setDiscountStrategy(new RegularCustomerDiscountStrategy());
        System.out.println("Regular customer: " + cart.checkout(originalPrice));

        cart.setDiscountStrategy(new VipCustomerDiscountStrategy());
        System.out.println("VIP customer: " + cart.checkout(originalPrice));
    }
}

运行这个程序，你将看到每种客户类型的折扣策略对价格的影响。

策略模式和工厂模式的不同点？

策略模式和工厂模式是两种常见的设计模式，都用于处理创建和使用对象的问题，但他们解决的问题和使用场景有所不同。

策略模式(Strategy Pattern) 是一种行为型模式，它的主要思想是定义一系列的算法，将每一个算法封装起来，并使它们可以互相替换。策略模式让算法独立于使用它的客户而独立变化。策略模式主要用于选择并交换在运行时可能发生变化的行为策略。例如，你可能会根据不同的情况使用不同的排序算法或折扣策略。

工厂模式(Factory Pattern) 是一种创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户暴露创建逻辑，而是通过使用一个共同的接口来指向新创建的对象。工厂模式主要用于管理和控制复杂对象的创建过程，尤其是当对象的创建过程有许多步骤或需要使用特定的信息时。

简单来说，区别在于：策略模式是在运行时改变行为或算法，而工厂模式是用来创建对象，封装了创建对象的复杂性。

例如，在一个电商系统中，针对不同的用户可能有不同的折扣策略，此时就可以使用策略模式，根据用户类型动态选择合适的折扣策略。而如果需要创建用户对象，用户类型包括新用户、老用户和VIP用户，每种类型的用户创建过程都不同，这种情况下就适合使用工厂模式，用工厂类来负责创建不同类型的用户对象。