设计模式之策略模式

AlbertOS

已于 2022-06-08 22:03:50 修改

阅读量390

点赞数 1

分类专栏：设计模式文章标签：策略模式设计模式 java

于 2022-05-28 14:31:55 首次发布

本文链接：https://blog.csdn.net/Albert_weiku/article/details/125001523

版权

设计模式专栏收录该内容

13 篇文章 3 订阅

订阅专栏

文章目录

引入
适合用策略模式的场景
策略模式的定义
策略模式的结构
优点
策略模式相对于继承机制的优势
总结

引入

书接上回，我们来聊聊啥是策略模式？
这是一个将算法封装起来的模式，然后提供一个set函数来让它们可以相互替换，这个模式让算法可独立于使用它的客户而变化。

适合用策略模式的场景

一个类有很多种行为，使用这个模式可以避免在类中使用大量的条件语句（不同的用户调用，不要写成if判断是哪个用户，直接set设置就在同一个接口函数中表现出不一样的行为）
程序不希望暴露复杂的、与算法相关的数据结构
需要使用一个算法的不同变体

策略模式的定义

定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。

策略模式的结构

在这里插入图片描述

上下文对象中引用这个策略接口，具体是策略继承这个策略接口。上下文只需要向这个策略接口发消息就可以了~

上下文对象

//上下文对象
public class GymnasticsGame {
    Computable strategy;//保存策略的引用
    //用于设置切换哪个具体策略
    public void setStrategy(Computable strategy){
        this.strategy = strategy;
    }
    //委托函数，客户端程序不直接调用策略，而通过上下文对象转发，实现策略对象的共享
    public double getPersonScore(double[] a){
        if (strategy!=null)
            return strategy.computeScore(a);//调用具体策略的方法
        else
            return 0 ;
    }
}

策略接口

//策略接口
public interface Computable {
    public abstract double computeScore(double[] a);
}

具体的三种策略

public class StrategyOne implements Computable{
    //实现计算数组a的元素的代数平均值
    @Override
    public double computeScore(double[] a) {
        double score =0 , sum =0;
        for (int i = 0; i < a.length; i++) {
            sum = sum +a[i];
        }
        score = sum/a.length;
        return score;
    }
}
public class StrategyTwo implements Computable{
    //实现计算数组a的元素的几何平均值
    @Override
    public double computeScore(double[] a) {
        double score =0 , multi =1;
        int n = a.length;
        for (int i = 0; i < a.length; i++) {
            multi = multi * a[i];
        }
        score = Math.pow(multi,1.0/n);
        return score;
    }
}

public class StrategyThree implements Computable{
    //去调一个最大值、一个最小值，实现计算数组a的剩余元素的代数平均值
    @Override
    public double computeScore(double[] a) {
        if(a.length<2)
            return 0 ;
        double score =0 ,sum = 0;
        Arrays.sort(a);
        for (int i = 0; i < a.length-1; i++) {
            sum = sum +a[i];
        }
        score = sum/(a.length-2);
        return score;
    }
}

应用程序

public class Application {
    public static void main(String[] args) {
        GymnasticsGame game = new GymnasticsGame(); //new一个上下文对象
        game.setStrategy(new StrategyOne());//上下文对象设置使用策略一
        Person albert = new Person();
        albert.setName("albert");
        double[] a = {9,12,2,4,64,2,45,6,12};
        albert.setScore(game.getPersonScore(a));//赋值语句，这个调用方式就是直接调用上下文对象的getPersonScore函数
        System.out.println(albert.getName()+" 使用算术平均值方案, 求出的值为： "+albert.getScore());

        game.setStrategy(new StrategyTwo());//重新set上下文的具体策略
        albert.setScore(game.getPersonScore(a));
        System.out.println(albert.getName()+" 使用几何平均值方案, 求出的值为： "+albert.getScore());
    }

    //建立一个内部类，完善业务场景逻辑
    private static class Person {
        String name;
        double score;
        public void setScore(double score) {
            this.score = score;
        }
        public void setName(String name) {
            this.name = name;
        }
        public double getScore() {
            return score;
        }
        public String getName() {
            return name;
        }
    }
}