@Test public void test1(){ int a = 10,b =7; int[] compute = compute(a,b); System.out.println("两数之和："+compute[0]); System.out.println("两数之差:"+compute[1]); } private int[] compute(int a,int b){ return new int[]{a+b,a-b}; }- 显然这有致命的缺点，你无法通过下标直观的对应[0]是什么含义，[1]是什么含义，特别是别人阅读你的代码可能会有些许的压力。可维护性非常差。
- 同样一种比较常用的方式，参考代码如下
@Test public void test2(){ int a = 10, b = 7; IntBox aBox = new IntBox(a); IntBox bBox = new IntBox(b); compute2(aBox,bBox); System.out.println("两数之和：" + aBox); System.out.println("两数之差:" + bBox); } private void compute2(IntBox a,IntBox b){ int diff = a.value - b.value; int sum = a.value + b.value; a.value = sum; b.value = diff; } private class IntBox{ private int value; public IntBox(int value){ this.value = value; } @Override public String toString(){ return String.valueOf(value); } }缺点
- 基本类型不支持，必须封装成对象，比如上述代码封装了
IntBox，造成代码量冗长。 - 反代码阅读直觉，可读性极差。在别人阅读你的代码时，看到方法调用，一般认为传递了xx参数，获取到xx返回值，而不是参数都甚至被改变，这极大的增加了维护和理解成本，他为了了解参数被发生什么改变，甚至必须深入方法内部逻辑。
>
>
此方法由于过于反直觉、代码量冗长，可读性、可维护性极差，是充满妥协的解决方案。但由于是最简单的方法，所以在新手中不少见，我个人建议不到万万不得已，别使用。
比较容易想到的另一种方案，多返回值通过key-value形式返回，示例如下：
@Test public void test3(){ int a = 10,b =7; Map<String, Integer> resMap = compute3(a,b); System.out.println("两数之和：" + resMap.get("sum")); System.out.println("两数之差:" + resMap.get("diff")); } private Map<String,Integer> compute3(int a,int b){ HashMap<String, Integer> hashMap = new HashMap<>(); hashMap.put("diff",a-b); hashMap.put("sum",a+b); return hashMap; }- 此方式和数组返回值有相似的地方，可以当做前者的升级版，但map的key是可读的，而数组的下标是没有可读性的。
- 虽然消除了“数组返回值”时下标不可读性的理解困难问题，但引入的硬编码魔法值已经容易造成维护困难，比如后期可能忘记key的值是sum还是summation，甚至单词拼错都会把bug引入打运行时。这是动态语言常见的问题，在java身上不应该出现。
hashMap作为返回值时，最大的缺点就是key的值是string魔法值，消除魔法值常见的办法就是枚举。因此考虑枚举替代String作为key，代码如下
@Test public void test3(){ int a = 10,b =7; Map<ResType, Integer> resMap = compute3(a,b); System.out.println("两数之和：" + resMap.get(ResType.SUM)); System.out.println("两数之差:" + resMap.get(ResType.DIFF)); } private Map<ResType,Integer> compute3(int a,int b){ HashMap<ResType, Integer> hashMap = new HashMap<>(); hashMap.put(ResType.DIFF,a-b); hashMap.put(ResType.SUM,a+b); return hashMap; } enum ResType{ SUM, DIFF }emmm，比上述好得多了，但是还是有优化空间。
- 在方法中必须显式创建一个hashMap比较麻烦。
- 第9行map的泛型是可以不指定的，如果遇到不规范的队友，依旧存在硬编码问题。
- 必须多定义一个枚举，一定程度上增加代码量
创建自定义返回值MutiResult.java代码如下：
public class MutiResult<K extends Enum<K>,V>{ private Map<K, V> resultMap; private MutiResult(Map<K, V> resultMap){ this.resultMap = resultMap; } /** * 获取返回值 * * @param key * @return */ public V get(K key){ return resultMap.get(key); } public static <K extends Enum<K>,V> Builder<K, V> build(){ return new Builder<>(); } /** * @param keyClass key的类型 * @param valueClass value类型 * @return 建造者对象 */ public static <K extends Enum<K>,V> Builder<K, V> build(Class<K> keyClass,Class<V> valueClass){ return new Builder<>(); } /** * 建造者 * * @param <K> * @param <V> */ public static final class Builder<K extends Enum<K>,V>{ private Map<K, V> resultMap; Builder(Map<K, V> resultMap){ this.resultMap = resultMap; } Builder(){ this(new ConcurrentHashMap<>()); } /** * 生成目标类 * * @return */ public MutiResult<K, V> build(){ return new MutiResult<>(resultMap); } /** * @param key * @param value * @return * @throws IllegalArgumentException 多次添加同一个key抛出此异常 */ public Builder<K, V> add(K key,V value){ if(resultMap.get(key) != null){ throw new IllegalArgumentException("重复添加key：" + key); } resultMap.put(key,value); return this; } }使用方法：
enum ResType{ SUM, DIFF } @Test public void test4(){ int a = 10,b =7; MutiResult<ResType, Integer> resMap = compute4(a,b); System.out.println("两数之和：" + resMap.get(ResType.SUM)); System.out.println("两数之差:" + resMap.get(ResType.DIFF)); } private MutiResult<ResType, Integer> compute4(int a,int b){ return MutiResult.build(ResType.class,Integer.class) .add(ResType.SUM,a+b) .add(ResType.DIFF,a-b) .build(); }