Why this java application print "true"?

Question

This is my first Class Hello.java

public class Hello { String name = ""; }

This is my second Class Test1.java

public class Test1 { public static void main(String[] args) { Hello h = new Hello(); Test1 t = new Test1(); t.build(h); System.out.println(h.name); } void build(Hello h){ h.name = "me"; } }

When I run Test1.java, it prints "me". I think I understand, because of "reference transfer".

This is my third Class Test2.java

public class Test2 { public static void main(String[] args) { Hello h = null; Test2 t = new Test2(); t.build(h); System.out.println(h == null); } void build(Hello h){ h = new Hello(); } }

When I run Test2.java, it prints "true", why ? Is it "reference transfer" no longer? I am confused.

possible duplicate of Is Java pass by reference?

polygenelubricants
– polygenelubricants

2010-05-12 11:35:40 +00:00
Commented May 12, 2010 at 11:35 — polygenelubricants
– polygenelubricants, Commented May 12, 2010 at 11:35
Java passes by value. Java passes references by value.

polygenelubricants
– polygenelubricants

2010-05-12 11:36:01 +00:00
Commented May 12, 2010 at 11:36 — polygenelubricants
– polygenelubricants, Commented May 12, 2010 at 11:36
those much parentheses? fromer lisp programmer? :-P

Federico klez Culloca
– Federico klez Culloca

2010-05-12 11:38:14 +00:00
Commented May 12, 2010 at 11:38 — Federico klez Culloca
– Federico klez Culloca, Commented May 12, 2010 at 11:38

Johannes Weiss · Accepted Answer · 2010-05-12 11:39:30Z

As you probably know, Java is call-by-value. Wenn you pass a reference, that reference gets copied. To be sure: The reference itself and not the reference's target gets copied.

Let's have a look at your first sample: When calling build(), the reference h will be copied. Because h(the copy in build()) does not get overwritten somewhere in build(), it always points to the memory location of the original h. So changing h.name affects the original h.

Sample 2 is different: reference h gets copied, too. But h gets overwritten in build(). The effect is that the original h and the h in build() point to different memory locations! The h in build() points to the newly generated Hello object, which will be garbage collected somewhen after the return of method build().

Petar Minchev · Accepted Answer · 2010-05-12 11:34:00Z

Java is always pass by value. When you have references, it just passes a copy of the reference pointing to the same object. In your case, you just reroute the copied reference to another object. That's why your original one is not changed.

Fletcher Moore · Accepted Answer · 2010-05-12 11:44:19Z

You have two different variables h. The first one is local to main. The second one is local to build.

If you rename your build variable to x, it should become obvious why h in main is not affected.

Edit:

public class Test2 { public static void main(String[] args) { Hello h = null; Test2 t = new Test2(); t.build(h); System.out.println(((h == null))); } void build(Hello x){ x = new Hello(); } }

Here you can see clearly, x starts as null. Then x becomes a new object. Then x dies. h doesn't know anything about what's going on in x's life.

sepp2k · Accepted Answer · 2010-05-12 11:34:43Z

h.name = "me" changes the object that is referenced by h. This change will be visible from any other place where the same object is referenced. h = new Hello() makes h reference another (new) object. This change only affects that particular variable h - not any other variable that previously referenced the same object.

Tim Schmelter · Accepted Answer · 2010-05-12 11:37:00Z

0

Mybe this explains why: http://www.yoda.arachsys.com/java/passing.html

answered May 12, 2010 at 11:37

Tim Schmelter

462k79 gold badges719 silver badges980 bronze badges

Comments

Veera · Accepted Answer · 2010-05-12 11:51:27Z

In Test1.java, when you pass Hello object h to build() method, the variable main().h and build().h are pointing to same object in memory.

i.e. main().h = build().h => pointing same object

But in Test2.java, even though you pass main().h to build() method, later on inside build method, you're repointing build().h to a new object. But this does not affect the main().h

i.e. main().h != build().h // they both point different objects.

that is why main().h still contains null and your program prints true.

Phani · Accepted Answer · 2010-05-12 11:52:19Z

First of all you need to understand difference between Object and Reference.

In the first case, you are directly accessing object(memory in heap) and changing a value, where as in the second case the reference will have the new Object till the end of method. After that it will be no longer accessible.

 public static void main(String[] args){ String str = null; System.out.println(getString(str)== null); } public static String getString(String s){ s = new String(); return s; }

The above code will print false

corgrath · Accepted Answer · 2010-05-12 12:01:35Z

To put it simple:

1) You first create a variable 'h' and point it to null

2) When you come into the method "void build(Hello h)" you create a new variabel (also called 'h') which gets pointed to null (the pointer to what the variable is pointing towards is COPIED).

3) When you do 'h = new Hello()' you then change the new 'h' variable in the method to point towards a new instance of Hello (new Hello()).

The original variable called 'h' is unchanged.

Simple as pie.

carny666 · Accepted Answer · 2010-05-12 11:32:18Z

-1

Because h is equal to null.

answered May 12, 2010 at 11:32

carny666

2,4402 gold badges19 silver badges28 bronze badges

1 Comment

sepp2k Over a year ago

He's asking why h is equal to null, i.e. why doing h = new Hello() inside build does not affect the h in main.

Collectives™ on Stack Overflow

Why this java application print "true"?

9 Answers 9

Comments

Comments

Comments

Comments

Comments

Comments

Comments

Comments

1 Comment

Hot Network Questions

Collectives™ on Stack Overflow

9 Answers 9

Comments

Comments

Comments

Comments

Comments

Comments

Comments

Comments

1 Comment

Related