Java计算器到策略模式升级——枚举策略

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java计算器到策略模式升级——枚举策略，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3448字，纯文字阅读大概需要5分钟。

内容图文

上一次我们谈到了策略模式，这节我们就从最简单的计算器来更深入的了解策略模式。

首先我们来实现另一个最基础的计算器

public class Calculator {
    private final static String ADD = "+";
    private final static String SUB = "-";
    private final static String MUL = "*";
    private final static String DIV = "/";

    public int exec(int a,String symbol,int b){
        int result = 0;
        switch (symbol){
            case ADD:
                result = a + b;
                break;
            case SUB:
                result = a - b;
                break;
            case MUL:
                result = a * b;
                break;
            case DIV:
                result = a / b;
                break;
            default:
                result = -1;
        }
        return result;
    }
}

这个简单的加减乘法（精度都没考虑，我们主要是看策略模式的实现），大家肯定都会写，那我们直接在场景类中测试一下

public class Client {
    public static void main(String[] args) {
        Calculator cal = new Calculator();
        int a = Integer.parseInt(args[0]);
        String symbol = args[1];
        int b = Integer.parseInt(args[2]);
        System.out.println(Arrays.toString(args) + "=" + cal.exec(a, symbol, b));
    }
}

测试结果是没什么问题，但是我们只是用最简单的方法实现的，那我们怎么使用策略模式来实现呢

public interface Calculator {
    public int exec(int a, int b);
}

public class Add implements Calculator {
    @Override
    public int exec(int a, int b) {
        return a+b;
    }
}

public class Sub implements Calculator {
    @Override
    public int exec(int a, int b) {
        return a-b;
    }
}

public class Mul implements Calculator {
    @Override
    public int exec(int a, int b) {
        return a*b;
    }
}

public class Div implements Calculator {
    @Override
    public int exec(int a, int b) {
        return a/b;
    }
}

使用上下文把策略模式封装起来

public class Context {
    private Calculator cal;

    public Context(Calculator cal) {
        this.cal = cal;
    }

    public int exec(int a, int b){
        return cal.exec(a,b);
    }
}

public class Client {

    private static final String ADD = "+";
    private static final String SUB = "-";
    private static final String MUL = "*";
    private static final String DIV = "/";

    public static void main(String[] args) throws Exception {
        Context context = null;
        int a = Integer.parseInt(args[0]);
        String symbol = args[1];
        int b = Integer.parseInt(args[2]);
        switch (symbol){
            case ADD:
                context = new Context(new Add());
                break;
            case SUB:
                context = new Context(new Sub());
                break;
            case MUL:
                context = new Context(new Mul());
                break;
            case DIV:
                context = new Context(new Div());
                break;
            default:
                throw new Exception("符号输入错误："+symbol);
        }

        System.out.println(Arrays.toString(args) + "=" + context.exec(a, b));
    }
}

上述就是使用策略模式完成的基本计算器功能，代码和上节策略模式过程说的基本一致，但是我们发现是用来策略模式使我们的代码更得复杂了起来，就也体现出来策略模式的缺点——策略类的数量增多。

最后我们来看看枚举策略

public enum Calculator {
    ADD{
        @Override
        public int exec(int a, int b){
            return a+b;
        }
    },

    SUB{
        @Override
        public int exec(int a, int b){
            return a-b;
        }
    },

    MUL{
        @Override
        public int exec(int a, int b){
            return a*b;
        }
    },

    DIV {
        @Override
        public int exec(int a, int b) {
            return a/b;
        }
    };

    public abstract int exec(int a, int b);
}

我们继续看场景类

public class Client {

    private static final String ADD = "+";
    private static final String SUB = "-";
    private static final String MUL = "*";
    private static final String DIV = "/";

    public static void main(String[] args) throws Exception {
        int a = Integer.parseInt(args[0]);
        String symbol = args[1];
        int b = Integer.parseInt(args[2]);

        int result;
        switch (symbol){
            case ADD:
                result = Calculator.ADD.exec(a,b);
                break;
            case SUB:
                result = Calculator.SUB.exec(a,b);
                break;
            case MUL:
                result = Calculator.MUL.exec(a,b);
                break;
            case DIV:
                result = Calculator.DIV.exec(a,b);
                break;
            default:
                throw new Exception("符号输入错误："+symbol);
        }

        System.out.println(Arrays.toString(args) + "=" + result);
    }
}

内容总结

以上是互联网集市为您收集整理的Java计算器到策略模式升级——枚举策略全部内容，希望文章能够帮你解决Java计算器到策略模式升级——枚举策略所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端