Java Trivia

[wtd]

Let's see how good the resident Java gurus really are.

Two true or false tests.

In Java, all object types are passed by reference.

Java does not have pointers.

[rizzix]

True. True. (although java references can contain null values and are re-assignable, it really depends on ur definition of a pointer/reference.. in my books a pointer is somthing to which u can directy assign a physical address as in C-pointers.)

[wtd]

False and false.

Java:

public class Test {    public static void main(String[] args)    {       String str = "Foo";       System.out.println(str);       foo(str);       System.out.println(str);    }    public void foo(String s)    {       s = "Hello";    } }

Compare to:

c++:

#include <string> #include <iostream> void foo(std::string& s) {    s = "Hello"; } int main() {    std::string str("Foo");    std::cout << str << std::endl;    foo(str);    std::cout << str << std::endl;    return 0; }

And pointers exist.

See NullPointerException.

[rizzix]

I got a better one for you.. (everyone is free to answer.. the first one give the right answer will get 200 bits)

Now here's the question, explain me why the follow code results true:

Java:

String s1 = "hello world"; String s2 = "hello world"; s1 == s2; // true

[rizzix]

it's funny but you are wrong both times

(yes i know it appears to be soo but it isin;t) you just happened to pick a poor example (the java String object)

Explaination:

first let's look at your code

code:

public class Test {    public static void main(String[] args)    {       String str = "Foo";       System.out.println(str);       foo(str);       System.out.println(str);    }    public void foo(String s)    {       s = "Hello";    } }

Now here's the deal..
when passing str to foo.. what actually happens inside foo is this:

Java:

String s = foo

Basically the reference s now points to foo.. so if u reassign s a new object i.e ("hello").. that does not mean u are infact re-assigning foo the object "hello".

a better example would be this (cuz strings are immutable objects):

code:

public class Test {    class A {        private String str;        public void setStr(String s) {            str = s;        }        public String toString() {            return str;        }    }    public static void main(String[] args)    {       A obj = new A();       a.setStr("foo");       System.out.println(a);       foo(a);       System.out.println(a);    }    public void foo(A a)    {       a.setStr("Hello");    } }

[wtd]

Quote:

Both s1 and s2 are in fact pointers (Java goes to great pains to hide this fact), and both are pointing to the same value. Since both strings can be determined at compile-time to be identical in value, and since Java's strings are immutable, it only allocates that string once. Thus both pointers are pointing to the same location in memory.

If we were to manually construct the string through concatenation, the Java compiler becomes incapable of (or unwilling to) determine whether they contain the same value, and thus we end up with two different locations in memory allocated. Since == tests for referential equality, this will now fail.

It can easily be seen from this example that == is a highly unreliable test to use here and the code should be rewritten using the "equals" method.

[rizzix]

ditto.

[wtd]

rizzix wrote:

it's funny but you are wrong both times

(yes i know it appears to be soo but it isin;t) you just happened to pick a poor example (the java String object)

Explaination:

first let's look at your code

code:

public class Test {    public static void main(String[] args)    {       String str = "Foo";       System.out.println(str);       foo(str);       System.out.println(str);    }    public void foo(String s)    {       s = "Hello";    } }

Now here's the deal..
when passing str to foo.. what actually happens inside foo is this:

Java:

String s = foo

Basically the reference s now points to foo.. so if u reassign s a new object i.e ("hello").. that does not mean u are infact re-assigning foo the object "hello".

a better example would be this (cuz strings are immutable objects):

code:

public class Test {    class A {        public String str;    }    public static void main(String[] args)    {       A obj = new A();       a.str = "foo";       System.out.println(a.str);       foo(a);       System.out.println(a.str);    }    public void foo(A a)    {       a.str = "Hello";    } }

You're still confused. When you pass "a" into "foo", you're copying the pointer value into a completely new variable. Of course, you then assign to a field of the object "a" is pointing to, which mutates that field. Sadly Java lacks a "const" context.

This has nothing to do with references.

c++:

#include <string> #include <iostream> struct A {    std::string str;    A() : str("Foo") { } }; void foo(A *a) {    a->str = "Hello"; }  int main() {    A *a = new A;    std::cout << a->str << std::end;    foo(a);    std::cout << a->str << std::end;    return 0; }

[rizzix]

No i'm not confused... You are... You're thinking too much in C++.
Java references are not like C++ references..


maybe this will explain it a bit better:

code:

String a = "abc"; System.out.println(a); String b = a; b = "xyz"; System.out.println(a);

notice just cuz i assigned b, a. does not mean a has changed to "xyz"


NOTE: i also updated my previous example to better represent what i was trying to say.

[wtd]

I'm not thinking in C++. It just happens to be convenient for this, having both pointers and references.

[rizzix]

I told you java reference are not like c++ reference.. they point to objects yet they can't point to a physical address.

fact is.. c++ references are more like name aliases.

[wtd]

rizzix wrote:

code:

String a = "abc"; System.out.println(a); String b = a; b = "xyz"; System.out.println(a);

notice just cuz i assigned b, a. does not mean a has changed to "xyz"

Yes, you have two pointers: "a" and "b". You start out with "a" pointing to "abc".

You then have "b" point to the same location in memory that "a" points to.

You then decide that "b" should point to "xyz" instead.

Naturally, "a" is unchanged.

c++:

std::string *a = new std::string("abc"); std::cout << *a << std::endl; std::string *b = a; b = new std::string("xyz"); std::cout << *a << std::endl;

That's what the Java example is basically doing, though its syntax does a poor job of reflecting that behavior.

[wtd]

rizzix wrote:

I told you java reference are not like c++ reference.. they point to objects yet they can't point to a physical address.

But they do point to a physical address. You don't see that because Java doesn't want you to see its frilly underthings, but that's what's going on.

[rizzix]

*sigh* i'f you'd rather call it that..

Java references are very much liker perl references... they are logical.. they can't really point to anything physical.. it's all in the VM.

i can't really do this in java:

Java:

Object a = 0x1F23FA;

or something like that...

[rizzix]

wtd wrote:

rizzix wrote:

code:

String a = "abc"; System.out.println(a); String b = a; b = "xyz"; System.out.println(a);

notice just cuz i assigned b, a. does not mean a has changed to "xyz"

Yes, you have two pointers: "a" and "b". You start out with "a" pointing to "abc".

You then have "b" point to the same location in memory that "a" points to.

You then decide that "b" should point to "xyz" instead.

Naturally, "a" is unchanged.

Ditto similarly in your example the reference s (the parameter) is assigned to foo. Now do you see why reassigning s simply assigns s another object.... s is not an alias of foo!