设计模式学习--策略模式

最新推荐文章于 2024-05-30 16:41:52 发布

Scanf丶

最新推荐文章于 2024-05-30 16:41:52 发布

阅读量294

点赞数

分类专栏：学习 JAVA 文章标签：设计模式 JAVA 学习面向对象

本文链接：https://blog.csdn.net/qw7501312/article/details/52023106

版权

JAVA 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

学习

2 篇文章 0 订阅

订阅专栏

本文探讨了策略模式在面向对象编程中的重要性，强调了类的划分应基于抽象和封装原则。策略模式允许将算法封装并互换，确保算法独立于使用它的客户，从而促进代码的灵活性和可维护性。

摘要由CSDN通过智能技术生成

面向对象的编程，并不是越多类越好，类的划分是为了封装，但分类的基础是抽象，具有相同特性和功能的对象的抽象集合才是类。

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

—抽象策略角色：策略类，通常由一个接口或者抽象类实现。

—具体策略角色：包装了相关的算法和行为。

—环境角色：持有一个策略类的引用，最终给客户端调用。

/**
 * @Description 抽象算法类,定义所有支持的算法的公共接口
 */
public abstract class Strategy {
    //算法方法
    public abstract void algorithmInterface();
}

/**
 * @Description 具体算法A
 */
public class ConcreteStrategyA extends Strategy {

    //算法A实现
    @Override
    public void algorithmInterface() {
        System.out.println("算法A实现");
    }
}

/**
 * @Description 具体算法B
 */
public class ConcreteStrategyB extends Strategy {

    //算法B实现
    @Override
    public void algorithmInterface() {
        System.out.println("算法B实现");
    }
}

/**
 * @Description 具体算法C
 */
public class ConcreteStrategyC extends Strategy {

    //算法C实现
    @Override
    public void algorithmInterface() {
        System.out.println("算法C实现");
    }
}

/**
 * @Description 上下文 Context 用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用
 */
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void contextInterface(){
        strategy.algorithmInterface();
    }
}

public class Main {
    //客户端代码
    public static void main(String[] args) {
        Context context = null;
        context = new Context(new ConcreteStrategyA());
        context.contextInterface();
        context = new Context(new ConcreteStrategyB());
        context.contextInterface();
        context = new Context(new ConcreteStrategyC());
        context.contextInterface();
    }
}