Java中能否利用函数参数来返回值

左手的ㄟ右手 2022-06-07 04:48 153阅读 0赞

我们在写代码时通常会遇到一种情况，就是我们可能希望在一个函数操作完成后返回两个值，这两个值互不关联并且不希望以数组的形式返回，甚至这两个返回值都不属于同一种类型，这种情况下在C或C++中可以轻易的使用一个引用的参数来将想要返回的值作为参数传入函数，等函数执行完毕后就可以得到你想要的“返回值”了。   
但是这种情况在Java中可能就没有那么轻易了，我们知道Java语言最大的一项改变就是隐藏了类似C或C++中的指针操作，这给开发者带来了极大的好处，开始时不用在为调皮的指针头疼了，但是同样的，在某些场景下也会产生某些局限性，接下来我们来看看如果我们利用Java来完成C或C++中的通过函数来改变传入实参的值会出现哪些状况。   
首先，我们先来试试最最基本的int型变量，看如下代码：

package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            int a = 0, b = 1;
    
            System.out.println("Before swap: a is " + a + " b is " + b);
    
            swap(a, b);
    
            System.out.print("After swap: a is " + a + " b is " + b);
        }
    
        static void swap(int a, int b) {
            int tmp;
    
            tmp = a;
            a = b;
            b = tmp;
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22

如上所示，这是一个最基本的交换值的操作，在C或C++中我们可以很简单的利用swap(int &a, int &b)来完成相关的操作，但是在Java中我们看看这个程序的运行结果如下：

![int交换结果图][int]

我们不得不遗憾的发现类似于这样的基本类型想要通过函数参数来改变在Java中是不可能实现的，我们不禁想到，基本类型不行我们可以使用对象啊，对象在Java中确实传递的是地址，但是这个地址也有些微妙所在，我们看下面这个例子，仍然使用我们的神奇的交换函数，代码如下：

package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            StringBuffer a = new StringBuffer("hello a"), b = new StringBuffer("hello b");
    
            System.out.println("Before swap: a is " + a + " b is " + b);
    
            swap(a, b);
    
            System.out.print("After swap: a is " + a + " b is " + b);
        }
    
        static void swap(StringBuffer a, StringBuffer b) {
            StringBuffer tmp;
    
            tmp = a;
            a = b;
            b = tmp;
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22

这个程序的运行结果是怎样的呢？结果如下所示：

![StringBuffer交换结果图][StringBuffer]

这是为什么呢？我们要理解一个概念，那就是我们传地址实际上也是值传递，我们把实参存储的地址通过拷贝给了形参，在函数中传递参数后（还未做交换操作时）实参a与形参a的指向情况如下：

![交换前实参形参指向][SouthEast]

如上图所示，在传入参数时实参a将其存储的地址（@32，我们假设这个值是字符串”hello a”的地址）拷贝给了形参a，这时这两个对象均指向”hello a”。   
之后我们进行交换操作，交换操作完成后的指向如下所示：

![交换后实参指向][SouthEast 1]

此时我们发现我们仅仅是将形参的指向改变了，根本未能交换两个实参的指向，oh，no，到头来一场空。

我们试试下面的用法，具体程序如下：

package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            StringBuffer a = new StringBuffer("hello a");
    
            System.out.println("Before change: a is " + a);
    
            change(a);
    
            System.out.print("After change: a is " + a);
        }
    
        static void change(StringBuffer a) {
            a.append(" hello world");
        }
    }
    
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19

这里我们通过形参来改变实参指向的内容的值试试，运行结果如下：

![改变后实参内容][SouthEast 2]

嘿嘿，是不是还有点用，说到这里我们就明白了吧，我们改变指向是没用的，但我们去改变指向的内容的值是会生效的。

接下来我们不禁想到我们是不是可以用基础类型的封装类型来操作一波，封装类型是对象啊，这是毋庸置疑的，我们来看如下代码：

package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            Integer a = Integer.valueOf(0);
    
            System.out.println("Before change: a is " + a);
    
            change(a);
    
            System.out.print("After change: a is " + a);
        }
    
        static void change(Integer a) {
            a = Integer.valueOf(1);
        }
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18

来看看运行结果吧，如下所示：

![封装类型改变后实参内容][SouthEast 3]

是不是一脸懵逼，百思不得其解，接下来我们看看Integer的源码吧，代码如下：

public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
     
      
       1
       2
       3
       4
       5
       6

继续往下看，Integer(int i)的定义如下：

public Integer(int value) {
            this.value = value;
        }
     
      
       1
       2
       3

这个value是怎么定义的呢，我们看看，value定义如下：

/** * The value of the {@code Integer}. * * @serial */
        private final int value;
     
      
       1
       2
       3
       4
       5
       6

明白了吧，这个value它是个final类型的，简直坑爹，类似的封装类型都是这种调调，完全用不鸟，我们关于对象的举例为什么用了StringBuffer而不用String呢？因为String类型也是不会生效的，具体原因是为什么呢？我们就不再追代码了，实际上String虽然是一个对象类型，但其实它也是对char\[\]的封装，所以它也可以看作一个封装类型，因此，它也是不会生效的。   
好了，关于Java能否做到类似C语言改变传入实参的值的分析就到这里了，经过上述的分析，我们大致了解了其实对于Java来说这个用法其实并不怎么好用，还不如定义一个自己的数据类型来返回来的自由愉快，希望大家能够从我的这篇博客中学到新的知识，欢迎大家留言一起讨论。

[int]: /images/20220607/49cc05487ea24c3487920db578aeea1d.png
[StringBuffer]: /images/20220607/325f7487c7a44312bb97a4e32c7c535a.png
[SouthEast]: /images/20220607/711ff20ec41b4ef6aad25579913f5b6b.png
[SouthEast 1]: /images/20220607/d952e4b0a4254acfbbf954b8686eb0d2.png
[SouthEast 2]: /images/20220607/2e464718fc40478794c04dbdf796e298.png
[SouthEast 3]: /images/20220607/1fe2e0dde68e4f3daa3f32a796c03a83.png