java值传递与引用传递

java到底是值传递还是引用传递呢，这是在面试中经常被问到的问题。也有可能用java好久了好搞不清楚java参数传递到底是怎么传的，是值还是引用，或什么时候是值传递什么时候是引用传递，下面就带大家看一下，java传递参数。

值传递int：

public static void main(String[] args) {
        int j=5;
        testInt(j);
        System.out.println("main中的int值-----------"+j);
    }

    public static void testInt(int i){
        i=10;
        System.out.println("调用方法中的int值得"+i);
    }

输出结果：
**调用方法中的int值得10
main中的int值———–5**

上面代码通过main方法调用testInt()传递了一个int类型的参数，通过输出可以看到testInt方法中对int类型的参数做了修改，但是并没有影响到main方法中的int 值、这就是值传递，调用方法时只是copy了一个值，并没有把引用地址传递过去。

值传递double：

public static void main(String[] args) {
        double d=6.66;
        testDouble(d);
        System.out.println("main中的double值-----------"+d);
    }

    public static void testDouble(double d){
        d= 8.88;
        System.out.println("调用方法中的double"+d);
    }

输出结果：
**调用方法中的double8.88
main中的double值———–6.66**

跟值传递int效果是一样的，都是传递一个copy的值。

值传递封装类/其他：

public static void main(String[] args) {
        Integer i=50;
        testInteger(i);
        System.out.println("main方法中的integer--------"+i);
    }
    public static void testInteger(Integer i){
        i=100;
        System.out.println("调用方法中的integer------------"+i);
    }

输出结果：
**调用方法中的integer————100
main方法中的integer——–50**

public static void main(String[] args) {
        Float f=new Float(7.77);
        testFloat(f);
        System.out.println("main方法中的Float--------"+f);
    }

    public static void testFloat(Float f){
        f=new Float(9.99);
        System.out.println("调用方法中的Float------------"+f);
    }

输出结果：
**调用方法中的Float————9.99
main方法中的Float——–7.77**

public static void main(String[] args) {
        String s="我是main方法中的s";
        testString(s);
        System.out.println(s);
    }

    public static void testString(String s){
        s="我是调用方法中的s";
        System.out.println(s);
    }

输出结果：
**我是调用方法中的s
我是main方法中的s**

总结：基本类型与封装类型String等是靠copy值传递的。还有很多类型需要大家去验证
Integer 和 String 一样。保存value的类变量是Final属性，无法被修改，只能被重新赋值／生成新的对象。 当Integer 做为方法参数传递进方法内时，对其的赋值都会导致 原Integer 的引用被 指向了方法内的栈地址，失去了对原类变量地址的指向。对赋值后的Integer对象做得任何操作，都不会影响原来对象。

引用传递Array

    public static void main(String[] args) {
        String [] s=new String[]{"main-s[0]"};
        testArray(s);
        System.out.println(s[0]);
    }

    public static void testArray(String [] s){
        s[0]="test-s0";
        System.out.println(s[0]);
    }

输出结果：
**test-s0
test-s0**

main方法中调用test方法传递了一个String[]的参数，在test方法中修改了数组内的元素。main方法的数组元素做了改变，这说明数组是引用传递。调用test方法的时候只是传递了一个数组的一用。

引用传递List

public static void main(String[] args) {
        List<Integer> list=new ArrayList<Integer>(2);
        list.add(1000);
        System.out.println("调用方法前-----------"+list.size());
        testList(list);
        System.out.println("调用方法后---------------"+list.size());
    }

    public static void testList(List<Integer> list){
        list.add(10);
        list.add(100);
        System.out.println("调用方法中----------"+list.size());
    }

输出结果：
**调用方法前———–1
调用方法中———-3
调用方法后—————3
**
test方法中的add操作的也是对象的引用地址，所以main方法中的list的值也做了改变。

引用传递自定义对象

自定义类：

public class Test1 {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void test(){
        System.out.println("类test方法输出----"+this.getName());//输出当前name值
    }

}

测试代码：

public static void main(String[] args) {
        Test1 test=new Test1();
        test.setName("main-setName----");
        testReference(test);
        System.out.println("main方法中输出----"+test.getName());
    }

    public static void testReference(Test1 test1){
        System.out.println("调用方法中输出----"+test1.getName());
        test1.setName("testReference-setName");
        test1.test();
    }   

输出结果：
**调用方法中输出—-main-setName—-
类test方法输出—-testReference-setName
main方法中输出—-testReference-setName**

在main方法中创建一个Test1对象，对对象设置name属性值，然后调用testReference传递Test1对象，在testReference输出的值是在main方法中设置的，在testReference修改了应用对象的name属性值，在mian方法中在输出name值就会编程testReference中设置的name属性值。

总结：对象就是传引用地址。

以上就是本人对至传递与引用传递的理解，如有不对或者偏离的地方请大家多多指教，大家也可关注微信公众号进行交流，扫码关注！