运行结果你是什么。。

最后一个5我也不明白，等大神来解答Integer 是对象啊，怎么值没变，内存怎么画的

跑了下，果然最后一个是5，难道是java自动解包为int的效果吗？

如果自己解包为int,那就好解释了，直接值传递，6为方法内的，没有带出方法，main中的依然为5

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下

java中都是值传递，没有引用传递

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}刚洗澡想通了 public final class Integer extends Numberimplements Comparable<Integer> 这货跟String 一样是final的，全通了

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}
是滴，从某个角度来说，java中就只存在值传递

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}刚洗澡想通了 public final class Integer extends Numberimplements Comparable<Integer> 这货跟String 一样是final的，全通了final 的啊，我擦。龙套了

刚洗澡时想到了这种可能，也是一种非常合理的可能，回来查了下API，果然被猜中了，哈哈。

String是不可变类StringBuffer是可变的，b是StringBuffer，刚论证完Integer也是不可变的。

这个题 a是值传递，bcd是引用传递。不同于bc的是，d传引用进去后，参加运算时，因为Integer为final型，值不可变，所以重新在堆中new 了一个新的Integer，将值赋为6，但出方法后，这个6就没有再被引用了，main方法中的d依然指向最初的5的那个内存地址。

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}刚洗澡想通了 public final class Integer extends Numberimplements Comparable<Integer> 这货跟String 一样是final的，全通了final 的啊，我擦。龙套了
不是因为final的原因，你可以自己写一个类，定义成final的，当传入的时候一样会改变，不存在不可变类对象传递就不会改变，这跟可变不可变没关系

为什么在这里会自动解包啊。这里传的是个Integer 对象吧。我在DEBUG看一下
    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }元首，我刚才DEBUG了，发现传值的时候，确实把地址传过去了，
但是public static void getRes(Integer d) {//传过来的时候id=27
d = d + 1; // 这时id=37，说明这是一个新对象，原对象的值未改变
}刚洗澡想通了 public final class Integer extends Numberimplements Comparable<Integer> 这货跟String 一样是final的，全通了final 的啊，我擦。龙套了
这根final不final没有关系、、

String是final的，当你在方法中传递String时是引用传递，但是你不能改变这个String对象的值.我一直是这么理解的那应该咋回事？

JAVA中的参数传递全是以值传递的。是基本类型，就copy一个基本类型传进方法；是引用，就拷贝一个引用地址传进去方法，而并不是直接把地址交给他
public final class A {

int x =10;

public static void p(A a) {
a = new A();
a.x = 5;
}

public static void main(String args[]) {
A a = new A();
System.out.println(a.x);
p(a);
System.out.println(a.x);
}

}
我定义了一个final的A,穿进去把a重新指向了一个新的对象。改变他的属性值，而方法执行之后，打印a还是指向之间那个对象，说明我们传的是引用的值。而不是类似C++引用传递

java还有引用传递？不都是值传递吗？

String是final的，当你在方法中传递String时是引用传递，但是你不能改变这个String对象的值.我一直是这么理解的那应该咋回事？至于他这个StringBuffer为什么会打印sbsb，是因为把sb的地值copy传过去了，但仍然指向的是同一个对象，并未指定新的对象，所有看上去向是传的地址，实际是引用的值的拷贝

这得看你执行的操作有没有new新对象吧，反正记住引用记录了对象的地址，而给方法传引用类型参数，实际是把这个地址值的copy传过去了

除了public static void getRes(StringBuffer b){ b.append("sb");}
public static void getRes(int[] c) { c[0] = c[0]+1;}
这两个的值会发生改变,其他的没影响!

元首，java的值传递，你说的我明白了。public static void getRes(String a) { //这传的是一份地址的拷贝
a = a + "sssss"; //这里a+"ssss"赋值给"a"后，此时的a是一个新对象
}
但是StringBuffer 操作的是同一地址的"内容(sb)"，是这样吧

还没明白，String 指向新对象了，Integer指向新对象了，StringBuffer没有，这个怎么判断，String和Integer对象不可变吗？

还没明白，String 指向新对象了，Integer指向新对象了，StringBuffer没有，这个怎么判断，String和Integer对象不可变吗？
a = a+"sssss"会创建新对象啊，StringBuffer的append方法不会产生新对象。。

还没明白，String 指向新对象了，Integer指向新对象了，StringBuffer没有，这个怎么判断，String和Integer对象不可变吗？
a = a+"sssss"会创建新对象啊，StringBuffer的append方法不会产生新对象。。元首，讲讲String和Integer不创建对象的原因，顺便元首还知道哪些包装类像这样传不创建对象

其实这个问题应该这样理解public static void getRes(Integer d) { d = d+1;}
这里 d=d+1，d是一个新的引用，其实里面有se5里面的自动装箱和拆箱，其实真正的源码应该是d=new Integer(d+1);当然d+1也是拆箱，这里其实new了一个新对象，其实就是一个新的引用指向了真正的对象d+1的存储单元，在主程序的d引用其实没有改变，这不同于普通对象的传递，普通对象传入getRes(Entity e),e也是一个不同于主程序里面的另一个引用，但是用set修改属性时，始终指向的是原来的存储单元，所以主程序里面e指向的存储单元改变，值改变

其实所有的原因都是因为不可变类和可变类，jdk的不可变类：jdk的java.lang包中 Boolean, Byte, Character, Double, Float, Integer, Long, Short, String.这些类传递时，都会new新的对象出来，final只是保证该类不可被继承。
可以参考可变类与不可变类

你当然可以记下来这些是不可变类，但是我觉得更深层次的原因是s = s+"str"，为什么类对象可以和字符串相加，它是执行什么操作以及引用,基本类型和对象分别存储在哪
如果你能够分析出来，才能说你的基础不错

你当然可以记下来这些是不可变类，但是我觉得更深层次的原因是s = s+"str"，为什么类对象可以和字符串相加，它是执行什么操作以及引用,基本类型和对象分别存储在哪
如果你能够分析出来，才能说你的基础不错 java运行时的内存分配图，看过几次，现在就记住了对象堆栈的分配，还是要多看

其实这个问题应该这样理解public static void getRes(Integer d) { d = d+1;}
这里 d=d+1，d是一个新的引用，其实里面有se5里面的自动装箱和拆箱，其实真正的源码应该是d=new Integer(d+1);当然d+1也是拆箱，这里其实new了一个新对象，其实就是一个新的引用指向了真正的对象d+1的存储单元，在主程序的d引用其实没有改变，这不同于普通对象的传递，普通对象传入getRes(Entity e),e也是一个不同于主程序里面的另一个引用，但是用set修改属性时，始终指向的是原来的存储单元，所以主程序里面e指向的存储单元改变，值改变同意,应该就是这样吧.再底层的东西也没那能力研究......
String a="a";int b=1;//存储方式相同
String a=new String("a"); Integer b=new Integer(1);//存储方式相同
a+"aaa"; b+1;//在处理上应该是相同,都创建的新对象

觉得还是从可变类和不可变类的角度来理解更好懂一点，因为是不可变类，所以参加运算时，就新 new 了对象。导致新的结果不能存在之前的内存地址，原来的值依然存在。

“可变类和不可变类”没听过这种定义，是不是把final理解错了
fianl修饰类，只说明类不可被继承。final类的所有方法默认是final的，不可重写，因为类不能继承，就不肯能重写。如String。
fianl修饰变量，表示变量所指向的地址不可修改，即指向的对象不可变。对象里的属性是可变的。

“可变类和不可变类”没听过这种定义，是不是把final理解错了
fianl修饰类，只说明类不可被继承。final类的所有方法默认是final的，不可重写，因为类不能继承，就不肯能重写。如String。
fianl修饰变量，表示变量所指向的地址不可修改，即指向的对象不可变。对象里的属性是可变的。
恩是的我之前对类前面的final理解不到位，造成了理解的错误。不可变类，一旦创建，变不可再修改其值，所以String Integer等类new出的对象参加运算时，都会生成新的对象，不可修改之前传入的对象值。final 只强调该引用指向的内存地址不可改变，如试图改变final修饰的对象的内存地址，编译报错。

调试易

运行结果你是什么。。

解决方案 »