一个有关java Boolean的小问题请高手帮忙解答

Question

public class study {
public static void test(Boolean bl) {
bl = new Boolean("false");
}
    public static void main(String[] args) {
     Boolean bl = new Boolean("true");
        test(bl);
     System.out.println(bl.toString());
    }
}
为什么输出的是true而不是false?

Answer 1

java对象的引用传递而不是值传递。
在public static void test(Boolean bl）方法中
b1是test方法内的局部变量，
它的修改不会引起main中b1的修改

Answer 2

是对象就传引用，是基础类型就传复制后的副本，你把test方法中的形参改个别的名字就不容易混淆了，写成相同的变量名一般都是面试题的奇怪做法。

Answer 3

bl = new Boolean("false");执行这个语句，并不是修改了bl对象的值，而是修改了bl对象的指向，所以外部main方法中的bl不会受到影响。

Answer 4

直接修改bl对象中的属性就可以改变输出结果了:
// bl.value = false;
Field f = bool.getClass().getDeclaredField("value");
f.setAccessible(true);
f.set(bl, new Boolean("false"));

Answer 5

大哥。你千万别再这么说了。
你都说了修改了b1对象的指向了，那么b1应该被修改到指向false而不是原来的true了。还有2楼的说法。你说不是值传递而且引用传递，引用没变啊。只是在调用方法的时候将b1复制了一份作为参数而已。 楼主可以这么理解：java方法的参数都是通过复制别的值而来的，而原来的值并没有变化。不管是复杂数据类型还是简单数据类型都是这样的。复制一份拿过去用。而不动本身。  这和堆、栈、串池等内存区域有关，建议楼主看看孙卫琴的那么java基础。好像叫java编程思想。挺好的。

Answer 6

根本就是胡说！你试一下这个：
public class Test {
    public static void a(List l) {
        l.add("aaa");
    }    public static void main(String[] args) {
        List l = new ArrayList();
        a(l);
        System.out.println(l.size());
    }
}打印的size是1，表示方法a的代码导致了l内容的改变因为在方法a中，并不是修改l的指向，而是修改了l的值
简单的说l在等号左边都是修改指向，对外部对象不会产生影响，但是调用l中的方法，并且这个方法会影响到这个对象的值，则外部对象也同样会受到影响

Answer 7

引用指向的是堆区中的一块地址，这个地址也就是对象的值【类似于java.lang.String@23dsfsf3】，他说修改了对象的指向，那么请问楼上的，修改了对象的指向，那这个对象的值不变么。

Answer 8

建议先理解对象和引用的区别。或者找本好书看看，比如《Core Java》

Answer 9

。。你根本没明白我在说什么
 我说的是 楼主的代码在那个方法里new 了一下，你就说修改了b1对象的指向，当然我不知道你说的是main中的b1，还是方法中的参数b1， 但是我想请问一下，如果不调用那个方法，那参数b1根本都不存在，何来改变它的引用一说呢？？？
那你试一下下面的方法public class Test {
  public static void a(List l) {
  l = new ArrayList();
  l.add("aaa");
  }  public static void main(String[] args) {
  List l = new ArrayList();
  a(l);
  System.out.println(l.size());
  }
}
打印结果依然是--0

Answer 10

JAVA在处理方法参数的时候到底是值传递还是引用传递本来就是两个观点，但是拿一种观点去解释另一种观点，这
public class Shot {

public static void main(String[] args) {

Shot s = new Shot();
System.out.println(s);

f(s);
} public static void f(Shot s){
System.out.println(s);
}
}
这段代码打印的都是一样的，都是对象在内存中的地址，java中不能直接操作对象，所以就只能通过地址来操作，那么像您举出来的那段代码，在main中声明的List和参数中的List的地址本来就是相同的，没有改变，所以在方法中改变了属性当然原来的也会变化。 那么您会说楼主的那段代码。 在main中，b1存在于栈区，指向new Boolean的一块堆区，但是在调用方法的时候，又new了一块堆区，我说了是复制之后，那你改变了复制后的值，和原来的值有什么关系呢？

Answer 11

大家不要吵，目的只是把问题搞清楚吗...无论传值还是传引用（或者说是地址），实际上都是将实参赋给形参，方法体内仅仅是对形参进行操作。但是传址的情况下，可以保证形参和实参同时指向一个内存地址（不应该new一个新的对象给形参），也就会起到修改实际内容的作用。

Answer 12

我说一下我的理解吧。public class study {
public static void test(Boolean bl) {
bl = new Boolean("false");
}
  public static void main(String[] args) {
  Boolean bl = new Boolean("true");
  test(bl);
  System.out.println(bl.toString());
  }1. 主函数执行，先给主函数中的bl new 了一块空间，假设为空间1，并赋值为true；
2. 然后执行test()函数，将主函数中的bl传给test()函数中的bl,即test()函数中的bl指向了空间1；
3. 当执行到test()函数中bl = new Boolean("false")这句时，实际上是重新new 了一块空间，假设为空间2，赋值为false,并将test()函数中的bl从原来指向空间1改为指向空间2，主函数中的bl指向的仍是空间1；
4. test()函数执行完了，则test()函数中的bl也结束了生命，但主函数中的bl仍指向空间1；
5. 然后就是执行System.out.println(bl.toString())，显然打印的是空间1中的内容，即true。}

Answer 13

Boolean,String,Integer,Double等这些类都比较特殊，参数传递的时候是当作基本数据类型来对待的

Answer 14

public class Test2{ public void modify(Bean b){
b.name="new name" ; }
public static void main(String [ ] args){
Test2 t = new Test2();
Bean b = new Bean ("old name");
t.modify(b);
System.out.println(b.name); }}
class Bean {
public Bean (String name){
this.name=name;
}
public String name ;
}

Answer 15

此楼的解释完全正确，你可以写个函数看一下，
：
有一个全局变量 int a=5;public void add(int b)
{
 b+=b;
}
 public static void main(String[] args) {
        
      add(a);
System.out.println(a);//看一下输出的值是几啊，呵呵
    }

Answer 16

如果是下面这样的代码，输出的结果还是true,引用和指针有区别，指针可以做算术运算 ++，--等
我们依然可以把引用和指针比作门牌号，门牌号的指向的是房间，我们是通过门牌号找到房间，把房间里面的内容改变了，而不是复制了一个房间，把房间里的内容改变了，这和原来的房间一点关系都没有。按这样的理解应该输出的是false，可能像16楼和18楼说的那样，他们传递的时候是作为基本数据类型传递的
public class study {
public static void test(Boolean b) {
b = Boolean.FALSE;
}
    public static void main(String[] args) {
     Boolean bl = Boolean.TRUE;
        test(bl);
     System.out.println(bl.toString());
    }
}

Answer 17

我把test的形参名改成b2. 程序结果是一样的吧。public class study {
public static void test(Boolean b2) {
b2 = new Boolean("false");
}
  public static void main(String[] args) {
  Boolean bl = new Boolean("true");
  test(bl);
  System.out.println(bl.toString());
  }
}
那么问题来了， 为什么应该返回 false呢？ b1和b2又不是一个东西。

Answer 18

其实你可以简单理解成这样首先，在原来的main函数中有：Boolean bl = new Boolean("true");
然后，当执行test(bl)传递参数时，可以把这个参数bl视为这样一个局部变量：Boolean bl = main中的那个bl;，并且这个参数叫什么都无所谓
那么如果在这个test函数中执行bl = XXX;的时候改变的只是test中这个局部变量，main函数中bl完全不受影响

Answer 19

java 传值传引用，去百度下。

Answer 20

main bl -> new Boolean("true")
test bl -> new Boolean("false")
print bl 是main方法的bl 而不是test的bl
test

Answer 21

我的观点是
对于基本数据类型int boolean float double ,
    及其包装类型Integer ,Boolean ...
    及String 
    是值传递 ，在方法内对参数的修改只影响方法内，对于其他对象（包括自定义的类，如测试中的Bean ） 则是引用传递  public class a {
public static  void modify(String  b)
{
b="b" ;
} public static  void modify(int   b)
{
b=2 ;
}
public static  void modify(Boolean   b) {
b = new Boolean ("true");
} public static  void modify(Bean   b) {
           b.name="new";
}
public static void main(String[] args) {
String a ="a" ;
modify(a);
System.out.println(a.equals("a")?"String 成员变量":"String 局部变量"); int b=1;
modify(b);
System.out.println(b==1?"int 成员变量":"int 局部变量"); Boolean  bl= new Boolean ("false");
modify(b);
System.out.println(bl==false?"Boolean 成员变量":"Boolean 局部变量");
Bean bean= new Bean ("old");
modify(bean);
System.out.print("普通java对象   ");
System.out.println(bean.name.equals("old")?"成员变量":"局部变量");
} }
class Bean {
public Bean (String name){
this.name=name;
}
public String name ;
}

Answer 22

你的Bean测试方法就不对……
如果你写成
public static  void modify(Bean   b) {
    b = new Bean("new");
}
你觉得会如何？

Answer 23

到目前看到的书里Java中都是值传递，不同的是
对于简单类型，就是真实的值传递，对于引用类型，也是值传递，只不过这个“值”指的是在栈中的地址（原始地址的一个副本），引用类型在方法间传递时，传递的是地址，在方法中进行一系列改变后栈中的地址没有改变，而地址指向的堆中的值改变了。

Answer 24

list中装的是内存地址而不是对象

Answer 25

可以看下这个帖子
http://blog.csdn.net/abang8114/archive/2008/01/31/2075351.aspx

Answer 26

招兼职 调查填表任务，100元/天，大约工作2小时左右
要求得会发送email因为很多任务都是到邮箱里确认，每天大约需要2小时，时间您自己定，完成任务后第3天付款（有些调查需要审核，胡乱填写是无法通过的）所以请务必认真； (加入兼职网不需交任何费用，需要交费的都啥意思您懂得- -！) 点击这里马上注册：http://tinyurl.com/1227365

Answer 27

test()方法中 bl = new Boolean("false");这句话改变的只是该方法中的局部变量，并没有改变main方法中的b1所指的对象。

Answer 28

你想让main中的b1 改变    test()方法中添加返回参数附给b1

Answer 29

main中语句
test(bl);
在传参时相当于把bl值拷贝了一份传递给了test方法，
main中bl不受影响！

Answer 30

Boolean是一个对象所以 传的是引用 
JAVA核心技术里有讲到传参的三点：
1。不能修改基本数据类型参数。
2。可以改变对象参数的状态。
3。传参时不能让对象参数引用一个新对象LZ这属于第三点。7楼的属于第二点

Answer 31

public final class Boolean implements java.io.Serializable, Comparable<Boolean> {...}
final 类不能修改，看看String 和 StringBuffer的区别就明白了