话不多说，直接上代码
 
一、代码
 
    @org.junit.Test
    public  void test7(){
        int a= 3;
        add(a);
        System.out.println(a);
        List<String> list = new ArrayList<>();
        list.add("c");
        addList(list);
        System.out.println(list.size());
    }

    private void addList(List<String> list) {
        list.add("d");
    }

    private void add(int a) {
        a= a +4;
    }
 
二、结果
 
 
三、原因
 
因为int是基本数据类型，基本数据类型在java内存中是存在栈内存中的，一旦方法执行完后，会自动出栈，变量都会释放，空间消失。
 而对象在java中是存在堆内存中的，所以值会被改变。

 
简述
 
调用方法的时候，有需要传参数的情况。在Java中，参数的类型有基本类型和引用类型两种。
 
一开始听到一个说法，Java没有引用传递，但是一直没有太多的思考在上面，直到前不久玩数组的时候，突然间发现把数组引用变量作为参数传递到一个方法当中进行操作之后，再去访问原数组，尽然改变了。于是乎，就想到了之前在C++里面学过的引用传递，突然有一种错愕的感觉，就查了一些资料，探究当Java引用类型变量作为参数传递给方法的时候，到底是值传递还是引用传递。
 
结论：如果将Java引用类型变量作为参数传递给方法，是将引用变量的值传递给形参，而引用变量的值实际上就是引用对象在堆内存中的地址。也就是说，这个时候实参和形参指向了同一个对象，如果利用形参进行操作，操作的就是实参指向的对象，最后通过实参的那个引用访问，自然是被形参操作过的结果。
 
基本类型参数
 
基本类型参数是典型的值传递，著名的案例就是更换两个数的值。下面是这个问题的示例代码：
 
public class Main {
 
public static void main(String[] args) {
 
int num1 = 11;
 
int num2 = 22;
 
System.out.println("Before the call: num1 is " + num1 + " and num2 is " + num2);
 
swap(num1, num2);
 
System.out.println("After the call: num1 is " + num1 + " and num2 is " + num2);
 
}
 
public static void swap(int num1, int num2) {
 
System.out.println("num1 is " + num1 + " and num2 is " + num2 + " in method of swap.(before)");
 
int tmp = num1;
 
num1 = num2;
 
num2 = tmp;
 
System.out.println("num1 is " + num1 + " and num2 is " + num2 + " in method of swap.(after)");
 
}
 
}
 
运行结果如下
 
Before the call: num1 is 11 and num2 is 22
 
num1 is 11 and num2 is 22 in method of swap.(before)
 
num1 is 22 and num2 is 11 in method of swap.(after)
 
After the call: num1 is 11 and num2 is 22
 
通过运行结果，可以清楚地知道，通过这样的参数传递，交换的仅仅是形参的值，而main方法当中的两个数的值并内有发生变化。这就是值传递的结果。
 
引用类型参数
 
通过一个数组引用演示引用类型参数的传递效果
 
public class ArrayTest {
 
public static void main(String[] args) {
 
int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
System.out.print("Before calling the inversion: ");
 
for (int i : arr) {
 
System.out.printf("%3d", i);
 
}
 
System.out.println();
 
inversion(arr);
 
System.out.print(" After calling the inversion: ");
 
for (int i : arr) {
 
System.out.printf("%3d", i);
 
}
 
System.out.println();
 
setNull(arr);
 
System.out.println("@" + arr);
 
}
 
public static void inversion(int[] arr) {
 
int length = arr.length;
 
for (int i = 0; i <= length / 2; i++) {
 
int temp = arr[i];
 
arr[i] = arr[length - i - 1];
 
arr[length - i -1] = temp;
 
}
 
}
 
public static void setNull(int[] array) {
 
System.out.println("#" + array);
 
array = null;
 
System.out.println("$" + array);
 
}
 
}
 
程序运行结果：
 
Before calling the inversion:   0  1  2  3  4  5  6  7  8  9
 
After calling the inversion:   9  8  7  6  4  5  3  2  1  0
 
#[I@1d251891
 
$null
 
@[I@1d251891
 
程序中，在main方法中定义了一个数组，并且在类中定义了一个将数组元素倒置的方法inversion()，这个方法需要传入一个数组类型的引用。在main方法中调用这个方法，并将arr这个数组的引用作为参数传递给inversion方法，通过程序执行的结果，可以看到当inversion方法执行完毕，main方法中的arr数组的内容的确发生了倒置。
 
那么，这个时候是否就可以认为，引用类型的传递是引用传递而并非值传递呢？按照资料显示的，引用类型的参数传递传递的是引用变量的值，有什么方法可以证明一下呢？setNull()方法提供了这样的证明。
 
setNull方法的参数是数组的引用变量，程序中传入的是arr.进入方法，首先打印了array,然后将它置空再打印一次，然后在main方法中，打印arr的地址。程序运行的结果表示，array置空之前和arr指向的是同一区域，而后array=null却并没有影响到arr.
 
所以，可以肯定，当一个引用类型的变量被作为参数传递到方法中的时候，仅仅是将变量值复制后传递过去，而本身没有发生改变去指向其他。
 

 
当array=null的时候，array指向堆区的引用失效了。
 
以上的示例和分析都表明，Java中的确没有引用传递，当把一个引用类型的变量作为参数传递给方法的时候，也仅仅是将引用变量的值复制一份给了方法中的参数，自己始终指向原本的对象。
 
以上所述是小编给大家介绍的Java引用类型的参数也是值传递详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！

 
1. 函数的参数类型def hs (a1, a2, a3,\u2026): * * * *语句a1, a2, a3是函数的参数。函数的参数类型可以分为:必需的参数,默认参数,变量参数(可变长度参数),关键字参数,参数组合,共有5个类型。2. 必需的参数。事实上,我们之前给的例子是必需的参数。下面的例子需要参数:在函数中我们可以看到,你好,str是一个参数,这是一个正式的参数。这个参数的类型取决于你的实际输入输入当你调用。参数类型,当我们调用这个函数你好,我们传递一个字符串\u201Chello, world\u201D,那么实际的类型参数是一个字符串,所以正式的类型参数str也是一个字符串,所以当我们调用这个函数你好,我们通过它进入'hello,世界\u201D,将执行print语句的函数,它将在屏幕上显示如图:值得注意的是,当我们定义的函数时,只有一个形状参数,所以我们通过在调用此函数在实际参数。
 
如果输入的参数比形状参数,将会有一个错误,如图:如果实际参数比形状参数,将报告一个错误。真正的参数小于形状参数。第二注意的是,当输入时将产生一个错误报告实际参数数量小于形状参数数量!正式的参数有一个参数,当调用函数没有参数传递,如图:2。默认参数默认参数在函数定义时,参数值。\u2026\u2026打印(\u201C我的名字:\u201C名称)(省略缺省参数)默认参数示例省略了实际参数23日得到结果。从上面的例子可以看到,上面的函数使用了两个正式的参数,当调用函数输入的两个实际参数,我们可以试着忽略实际参数23,看看我们可以得到结果,请参见图片:(改变默认参数的值),我们可以发现我们忽略实际的参数后23日23我们仍然可以获得实际的参数。
 
当我们调用这个函数时,如果默认的参数不是一个值作为实际参数,默认参数的值将被称为作为实际参数,所以我们会默认值;如果我们进入一个非默认参数值调用函数时,默认参数的值将改变在这个时间和成为所输入的值!如图:需要注意的是,当我们调用这个函数时,我们也可以进入'parameter name =价值\u201D的形式,如图:参数名称=值。这里的观点是:当有两个以上的默认参数和必需的参数调用函数参数时,你必须注意:答:当调用一个函数,实际参数形式的参数名称,如上图所示。b:一个参数有一个参数名称和其他参数没有参数名称。默认的参数必须是参数名c:如果默认参数在正式的参数是必需的参数,那么默认的参数在实际的参数调用函数时也应该在前面;
 
(默认参数在正式的参数,且默认参数在实际参数是在后面)默认的参数在正式的参数是第一,和默认的参数在实际参数后,导致一个错误:3。可变参数(可变长度参数)我们用一个例子来说明变量参数:打印(年龄)我insom:打印(i)返回可变长度参数我们可以看到,我们已经定义了两个参数在正式的参数。为什么正确进入4参数在实际参数?这是变量参数的好处!在代码中,实际的参数名称传递给形式参数的年龄,和其他三个* som传递。可以说,som相当于一个无限的容器,可以容纳很多参数。4. 事实上,关键字参数关键字参数出现在默认参数!关键字参数在函数被调用时,实际参数传递进来的参数名称,和实际参数以这种方式被称为关键字参数传递。
 
看一个例子:定义一个字典:\u2026print(学校:\u201D、学校\u201C\\ n,类:,banji,\u201C\\ n\u201D、\u201C学生信息:\u201D,其他)关键字参数示例1上面的例子我们可以看到,除了两个必需的参数'Tsinghua\u201D和'Sophomore\u201D,还有关键字参数\u201C* * dir\u201D当调用函数。让我们看看另一个例子:\u2026\u2026打印('就有:\u201C、学校\u201C\\ n\u201D、\u201CBanji:\u201D, Banji, ' \\ n ',\u2018Student_info:\u2019,其他)关键字参数示例2从上面的示例中,我们发现,当有一个不定长度参数*在正式的参数,使用* dir调用函数时只会发现结果是字典的键名,也没有价值!
 
5. 结合参数组合参数是将前面提到的4参数引入函数作为正式的参数在同一时间。值得注意的是,订单必须在定义参数:强制参数,关键字参数,默认参数和可变长度参数。举个例子:\u2026print (a1 =, a1, a2 =, a2、a3 =, a3, a4a =, a4, cs)(可变长度参数)第一次函数被调用时,1和2分别给a1, a2, a3正式参数= 10,但实际参数传入是3,改变初始值,所以a3 = 3 * a4无限期长度参数,4,5,6,7 * a4,所以a4a多个值,输出一个元组的形式,* * cs是一个关键字参数,所以的值m、n和* * xx是给* * cs,输出作为一个字典。第二次调用函数时,你是一个元组,和*涂方法调用时使用,所以a1 = 1 = 2 a2、a3 = 3, a4a = (4、5、6);

1.对于基本类型参数，在方法体内对参数进行重新赋值，并不会改变原有的变量的值。
 
2.对于引用类型参数，在方法体内对参数进行重新赋值引用，在方法体内使用的是引用的副本，不会改变原有变量的引用
 
3方法体内对参数进行运算不会影响原有的变量的值，但在方法体内对参数所指的对象的属性进行操作，将改变原有变量所指对象的属性值