Android 常用的设计模式 七 (Strategy（策略）模式)

1. MVC（Model-View-Controller）模式
2. MVP（Model-View-Presenter）模式
3. MVVM（Model-View-ViewModel）模式
4. Singleton（单例）模式
5. Factory（工厂）模式
6. Observer（观察者）模式
7. Strategy（策略）模式
8. Adapter（适配器）模式

这些设计模式都有不同的特点和用途，在开发 Android 应用程序时可以根据具体的需求进行选择。

在 Android 开发中，策略模式通常用于将不同的算法或行为封装成独立的类，从而在运行时动态地选择使用哪种算法或行为。这种设计模式可以实现代码的可扩展性和灵活性，并且避免代码的重复和复杂度。

通俗地说，策略模式就像是一种“换装”机制，它允许你在运行时根据需要选择不同的算法或行为，而无需改变程序的核心逻辑。这种机制可以帮助你解决不同场景下的问题，并且简化代码的维护和修改。

在策略模式中，通常会定义一个 Context 类作为环境，该类包含一个 Strategy 接口的引用，可以通过该接口来调用不同的算法或行为。具体的算法或行为则由不同的策略类来实现，这些策略类都实现了 Strategy 接口，并且提供了不同的算法或行为。

下面是一个简单的 Android 示例代码，演示了如何使用策略模式实现不同的排序算法：

// 定义策略接口
interface SortingStrategy {
    int[] sort(int[] input);
}

// 实现不同的排序算法
class BubbleSortStrategy implements SortingStrategy {
    @Override
    public int[] sort(int[] input) {
        // 实现冒泡排序
        return input;
    }
}

class QuickSortStrategy implements SortingStrategy {
    @Override
    public int[] sort(int[] input) {
        // 实现快速排序
        return input;
    }
}

// 定义上下文类
class SortingContext {
    private SortingStrategy mSortingStrategy;

    public void setSortingStrategy(SortingStrategy sortingStrategy) {
        mSortingStrategy = sortingStrategy;
    }

    public int[] sort(int[] input) {
        return mSortingStrategy.sort(input);
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        SortingContext context = new SortingContext();
        context.setSortingStrategy(new BubbleSortStrategy());
        int[] result = context.sort(new int[]{3, 1, 4, 1, 5, 9, 2, 6, 5});
        System.out.println(Arrays.toString(result));

        context.setSortingStrategy(new QuickSortStrategy());
        result = context.sort(new int[]{3, 1, 4, 1, 5, 9, 2, 6, 5});
        System.out.println(Arrays.toString(result));
    }
}

在上面的示例代码中，我们首先定义了一个 SortingStrategy 接口，用于实现不同的排序算法。然后我们实现了 BubbleSortStrategy 和 QuickSortStrategy 两个策略类，分别用于实现冒泡排序和快速排序算法。接着我们定义了一个 SortingContext 类，该类包含一个 SortingStrategy 接口的引用，并且提供了 sort() 方法，用于调用不同的算法或行为。

当我们需要根据不同情况采用不同的算法时，可以使用策略模式。策略模式定义了一组算法，将每个算法都封装起来，并使它们之间可以相互替换。这样，不同的算法可以独立于使用它们的客户端进行修改。

在 Android 中，策略模式通常用于处理类似于排序、搜索、加密等的场景。例如，可以根据用户的选择使用不同的排序算法来对列表进行排序。

下面是一个使用策略模式实现不同排序算法的示例代码：

首先，我们定义一个排序策略接口：

public interface SortStrategy {
    void sort(int[] data);
}

然后，我们可以实现不同的排序策略：

public class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 实现冒泡排序算法
    }
}

public class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 实现快速排序算法
    }
}

public class MergeSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 实现归并排序算法
    }
}

最后，我们可以定义一个排序器类，使用排序策略接口来进行排序：

public class Sorter {
    private SortStrategy mSortStrategy;

    public void setSortStrategy(SortStrategy strategy) {
        mSortStrategy = strategy;
    }

    public void sort(int[] data) {
        if (mSortStrategy != null) {
            mSortStrategy.sort(data);
        }
    }
}

在客户端代码中，可以按如下方式使用排序器和排序策略：

Sorter sorter = new Sorter();
sorter.setSortStrategy(new BubbleSortStrategy());
sorter.sort(data);

或者：

Sorter sorter = new Sorter();
sorter.setSortStrategy(new QuickSortStrategy());
sorter.sort(data);

这里，我们可以根据需要选择不同的排序算法，而不必修改客户端代码。这种做法不仅使客户端代码更加简洁，还使我们能够轻松地切换和测试不同的排序算法。