wordpress淘宝客网站模板,网站建设价表模板,郑州 服装 网站建设,基金项目实验室信息网站建设策略模式#xff08;Strategy Pattern#xff09;
概念 策略模式#xff08;Strategy Pattern#xff09;是一种行为型设计模式#xff0c;允许定义一系列算法#xff0c;将每个算法封装在策略类中#xff0c;并使它们可以互换使用。客户端可以根据需要动态选择不同的策…策略模式Strategy Pattern
概念 策略模式Strategy Pattern是一种行为型设计模式允许定义一系列算法将每个算法封装在策略类中并使它们可以互换使用。客户端可以根据需要动态选择不同的策略对象从而在运行时决定采用哪种具体算法。 应用场景 算法的可替换性当系统有多个不同的算法且这些算法可以互相替换时可以使用策略模式。例如排序算法、压缩算法等不同算法的实现。 避免条件分支当系统中存在大量的if-else或switch-case语句以选择不同的算法或行为时可以使用策略模式将这些条件分支移入不同的策略类中减少代码复杂度。 动态地选择行为策略模式允许在运行时动态地选择或切换不同的算法或行为。例如支付系统中可以选择不同的支付方式如信用卡、支付宝、微信等作为策略。 解耦行为与使用者策略模式使得具体的算法实现与使用算法的类解耦使用者无需了解具体的算法实现只需使用策略接口即可。 注意点
策略的数量随着算法或行为的增加策略类的数量也会增加可能会造成类数量的膨胀。策略的独立性策略类应当是独立的相互之间不应依赖。如果策略之间有逻辑关系可能需要进一步重构。客户端必须知晓策略客户端需要了解并决定使用哪种策略可能增加其复杂度。 核心要素
Strategy策略接口定义一系列可供选择的算法或行为。ConcreteStrategy具体策略具体的算法实现类每个策略类实现不同的算法。Context上下文类维护一个策略对象并根据客户端的选择动态使用不同的策略。 Java代码完整示例
代码示例简单策略模式
// 定义策略接口
interface Strategy {void execute();
}// 具体策略类 A
class ConcreteStrategyA implements Strategy {Overridepublic void execute() {System.out.println(使用策略A进行操作);}
}// 具体策略类 B
class ConcreteStrategyB implements Strategy {Overridepublic void execute() {System.out.println(使用策略B进行操作);}
}// 上下文类维护一个策略对象
class Context {private Strategy strategy;// 构造函数注入策略对象public Context(Strategy strategy) {this.strategy strategy;}// 动态设置策略public void setStrategy(Strategy strategy) {this.strategy strategy;}// 执行策略public void executeStrategy() {strategy.execute();}
}// 客户端代码
public class StrategyPatternDemo {public static void main(String[] args) {// 使用策略AContext context new Context(new ConcreteStrategyA());context.executeStrategy();// 切换到策略Bcontext.setStrategy(new ConcreteStrategyB());context.executeStrategy();}
}输出结果
使用策略A进行操作
使用策略B进行操作各种变形用法完整示例 策略模式结合枚举 通过枚举来实现策略模式每个枚举实例代表一种策略。 代码示例 enum PaymentStrategy {CREDIT_CARD {Overridepublic void pay(double amount) {System.out.println(使用信用卡支付: amount 元);}},PAYPAL {Overridepublic void pay(double amount) {System.out.println(使用PayPal支付: amount 元);}},ALIPAY {Overridepublic void pay(double amount) {System.out.println(使用支付宝支付: amount 元);}};public abstract void pay(double amount);
}public class PaymentContext {private PaymentStrategy strategy;public PaymentContext(PaymentStrategy strategy) {this.strategy strategy;}public void setStrategy(PaymentStrategy strategy) {this.strategy strategy;}public void pay(double amount) {strategy.pay(amount);}public static void main(String[] args) {PaymentContext context new PaymentContext(PaymentStrategy.CREDIT_CARD);context.pay(100.0);context.setStrategy(PaymentStrategy.PAYPAL);context.pay(200.0);context.setStrategy(PaymentStrategy.ALIPAY);context.pay(300.0);}
}输出结果 使用信用卡支付: 100.0 元
使用PayPal支付: 200.0 元
使用支付宝支付: 300.0 元策略模式结合Lambda表达式 在Java 8中可以使用Lambda表达式简化策略模式的实现将策略作为函数式接口来处理。 代码示例 interface Strategy {void execute();
}public class StrategyLambdaDemo {public static void main(String[] args) {// 使用Lambda表达式定义不同策略Strategy strategyA () - System.out.println(使用策略A执行操作);Strategy strategyB () - System.out.println(使用策略B执行操作);// 创建上下文并设置策略Context context new Context(strategyA);context.executeStrategy();context.setStrategy(strategyB);context.executeStrategy();}
}输出结果 使用策略A执行操作
使用策略B执行操作策略模式结合工厂模式 可以通过工厂模式来创建不同的策略对象并根据条件动态选择合适的策略。 代码示例 // 定义策略接口
interface Strategy {void execute();
}// 具体策略类 A
class ConcreteStrategyA implements Strategy {Overridepublic void execute() {System.out.println(使用策略A进行操作);}
}// 具体策略类 B
class ConcreteStrategyB implements Strategy {Overridepublic void execute() {System.out.println(使用策略B进行操作);}
}// 策略工厂类
class StrategyFactory {public static Strategy getStrategy(String type) {switch (type) {case A:return new ConcreteStrategyA();case B:return new ConcreteStrategyB();default:throw new IllegalArgumentException(未知策略类型);}}
}// 上下文类
class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy strategy;}public void executeStrategy() {strategy.execute();}
}// 客户端
public class StrategyFactoryDemo {public static void main(String[] args) {// 通过工厂创建策略对象Context context new Context(StrategyFactory.getStrategy(A));context.executeStrategy();context new Context(StrategyFactory.getStrategy(B));context.executeStrategy();}
}输出结果 使用策略A进行操作
使用策略B进行操作策略模式结合依赖注入 使用依赖注入框架如Spring动态选择策略这样可以将策略的选择交给框架来管理。 代码示例伪代码 // 定义策略接口
interface Strategy {void execute();
}// 具体策略类 A
Component(strategyA)
class ConcreteStrategyA implements Strategy {Overridepublic void execute() {System.out.println(使用策略A进行操作);}
}// 具体策略类 B
Component(strategyB)
class ConcreteStrategyB implements Strategy {Overridepublic void execute() {System.out.println(使用策略B进行操作);}
}// 上下文类
Component
class Context {private final MapString, Strategy strategies;// 使用Spring自动注入策略Mappublic Context(MapString, Strategy strategies) {this.strategies strategies;}public void executeStrategy(String strategyType) {Strategy strategy strategies.get(strategyType);if (strategy ! null) {strategy.execute();} else {throw new IllegalArgumentException(未知策略类型);}}
}// 客户端
SpringBootApplication
public class StrategySpringDemo {public static void main(String[] args) {ApplicationContext context SpringApplication.run(StrategySpringDemo.class, args);Context strategyContext context.getBean(Context.class);strategyContext.executeStrategy(strategyA);strategyContext.executeStrategy(strategyB);}
}输出结果 使用策略A进行操作
使用策略B进行操作通过这些不同的变形策略模式不仅能应对多种不同的需求场景还能与现代开发方法如枚举、Lambda、工厂模式、依赖注入等灵活结合进一步提升代码的可维护性和可扩展性。
