策略模式（Strategy Pattern）是一种行为设计模式，能在运行时根据对象的行为进行变化。在策略模式中，行为被封装到具有共同接口的独立类中，可以从一个对象中独立出一些行为的具体实现，进而在不同的情况下使用不同的行为。

策略模式通常包括以下三个部分：
策略接口（Strategy Interface）：这是所有策略必须遵循的接口。这通常是一个具有一个或多个方法的接口。
具体策略（Concrete Strategies）：这些类实现了策略接口，提供了策略接口声明的行为的具体实现。
上下文（Context）：这是一个类，它维护了一个对策略对象的引用，这个策略对象的类型是策略接口。上下文类可以定义一个接口，让上下文的客户端与策略交互。上下文类可以通过策略接口与策略对象交互，而不需要直接与具体的策略类交互。

策略模式的主要优点是它提供了一种替代继承的方法来处理一些特定问题，它使得算法可以独立于使用它的客户端。如何在 Flutter中使用策略模式。我们将通过两个实例来演示：支付和计算运费。
示例1：
开发一个购物应用，该应用支持多种支付方式（如信用卡支付、支付宝支付、微信支付等）。我们可以使用策略模式来处理支付功能，以便在运行时根据用户的选择来切换支付方式。
需求描述：
1.应用应支持多种支付方式。
2.用户可以选择他们想要的支付方式进行支付。
3.系统应根据用户选择的支付方式来处理支付。

使用策略模式来实现支付功能的示例：
定义策略接口：

abstract class PaymentStrategy {
  void pay(double amount);
}

定义具体策略：

class CreditCardPayment implements PaymentStrategy {
  // 堆代码 duidaima.com
  @override
  void pay(double amount) {
    print('Paying $amount using Credit Card');
  }
}

class AlipayPayment implements PaymentStrategy {
  @override
  void pay(double amount) {
    print('Paying $amount using Alipay');
  }
}

class WeChatPayment implements PaymentStrategy {
  @override
  void pay(double amount) {
    print('Paying $amount using WeChat Pay');
  }
}

定义上下文：

class ShoppingCart {
  PaymentStrategy? _paymentStrategy;

  void setPaymentStrategy(PaymentStrategy? strategy) {
    _paymentStrategy = strategy;
  }

  void checkout(double amount) {
    _paymentStrategy?.pay(amount);
  }
}

然后你可以在你的 UI 代码中使用这些策略：

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Strategy Pattern Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Strategy Pattern Demo'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  ShoppingCart _cart = ShoppingCart();

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            RaisedButton(
              child: Text('Pay with Credit Card'),
              onPressed: () {
                _cart.setPaymentStrategy(CreditCardPayment());
                _cart.checkout(100.0);
              },
            ),
            RaisedButton(
              child: Text('Pay with Alipay'),
              onPressed: () {
                _cart.setPaymentStrategy(AlipayPayment());
                _cart.checkout(100.0);
              },
            ),
            RaisedButton(
              child: Text('Pay with WeChat Pay'),
              onPressed: () {
                _cart.setPaymentStrategy(WeChatPayment());
                _cart.checkout(100.0);
              },
            ),
          ],
        ),
      ),
    );
  }
}

当用户点击按钮时，会使用用户选择的支付方式进行支付。在 PaymentStrategy 的 pay 方法中实现调用支付 API 的逻辑。
示例2：
开发一个电商应用，需要支持多种不同的运费计算策略（如免费运输、固定费用运输、按重量计费等）。可以使用策略模式来实现运费计算功能，以便在运行时根据用户的选择或特定条件来切换运费计算策略。
需求描述：
1.支持多种运费计算策略。
2.用户可以根据他们的需求选择不同的运费计算策略。
3.系统应根据用户选择的运费计算策略来计算运费。
使用策略模式来实现运费计算功能的示例：

定义策略接口：

abstract class ShippingCostStrategy {
  double calculate(double weight);
}

定义具体策略：

class FreeShipping implements ShippingCostStrategy {
  @override
  double calculate(double weight) {
    return 0.0;
  }
}

class FixedCostShipping implements ShippingCostStrategy {
  @override
  double calculate(double weight) {
    return 5.0;
  }
}

class WeightBasedShipping implements ShippingCostStrategy {
  @override
  double calculate(double weight) {
    return weight * 0.5;
  }
}

定义上下文：

class ShoppingCart {
  ShippingCostStrategy? _shippingCostStrategy;

  void setShippingCostStrategy(ShippingCostStrategy? strategy) {
    _shippingCostStrategy = strategy;
  }

  double checkout(double weight) {
    return _shippingCostStrategy?.calculate(weight) ?? 0.0;
  }
}

然后你可以在你的 UI 代码中使用这些策略：

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Strategy Pattern Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Strategy Pattern Demo'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  ShoppingCart _cart = ShoppingCart();
  double weight = 10.0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            ElevatedButton(
              child: Text('Free Shipping'),
              onPressed: () {
                _cart.setShippingCostStrategy(FreeShipping());
                print('Shipping cost: ${_cart.checkout(weight)}');
              },
            ),
            ElevatedButton(
              child: Text('Fixed Cost Shipping'),
              onPressed: () {
                _cart.setShippingCostStrategy(FixedCostShipping());
                print('Shipping cost: ${_cart.checkout(weight)}');
              },
            ),
            ElevatedButton(
              child: Text('Weight Based Shipping'),
              onPressed: () {
                _cart.setShippingCostStrategy(WeightBasedShipping());
                print('Shipping cost: ${_cart.checkout(weight)}');
              },
            ),
          ],
        ),
      ),
    );
  }
}

当用户点击按钮时，应用会使用用户选择的运费计算策略来计算运费。在 ShippingCostStrategy 的 calculate 方法中实现的运费计算逻辑。策略模式是一种非常有用的设计模式，它可以让你根据情况在运行时切换算法或策略。在 Flutter 中，你可以通过定义接口和实现这些接口的类来使用策略模式，然后在需要的地方使用这些策略。

策略模式可以提高代码的可读性和可维护性，因为它将算法的实现和使用它们的代码分离开来。此外，如果需要添加新的策略，只需要添加一个新的类，而不需要修改使用策略的代码，这符合开放封闭原则——对扩展开放，对修改封闭。
希望对您有所帮助谢谢!!！