Object and reference accessing for primitives, objects and collections

Question

Hi,
I have questions re objects, primitives and collection accessing and references
I made a simple class
public class SampleClass {
     private String attribute = "default";
     public SampleClass()
     public SampleClass(SampleClass psampleClass)
          this.setAttribute(psampleClass.getAttribute());
          if (this.getAttribute() == psampleClass.getAttribute())
               System.out.println("INSIDE CONSTRUCTOR : same object");
          if (this.getAttribute().equals(psampleClass.getAttribute()))
               System.out.println("INSIDE CONSTRUCTOR : equal values");
     public void setAttribute(String pattribute)
          this.attribute = pattribute;
          if (this.attribute == pattribute)
               System.out.println("INSIDE SETTER : same object");
          if (this.attribute.equals(pattribute))
               System.out.println("INSIDE SETTER : equal values");
     public String getAttribute()
          return this.attribute;
     public static void main(String[] args) {
...and another...
public class SampleClassUser {
     public static void main(String[] args) {
          SampleClass sc1 = new SampleClass();
          String test = "test";
          sc1.setAttribute(new String(test));
          if (sc1.getAttribute() == test)
               System.out.println("SampleClassUser MAIN : same object");
          if (sc1.getAttribute().equals(test))
               System.out.println("SampleClassUser MAIN : equal values");
          SampleClass sc2 = new SampleClass(sc1);
          sc1.setAttribute("test");
          if (sc2.getAttribute() == sc1.getAttribute())
               System.out.println("sc1 and sc2 : same object");
          if (sc2.getAttribute().equals(sc1.getAttribute()))
               System.out.println("sc1 and sc2 : equal values");
}the second class uses the first class. running the second class outputs the following...
INSIDE SETTER : same object
INSIDE SETTER : equal values
SampleClassUser MAIN : equal values
INSIDE SETTER : same object
INSIDE SETTER : equal values
INSIDE CONSTRUCTOR : same object
INSIDE CONSTRUCTOR : equal values
INSIDE SETTER : same object
INSIDE SETTER : equal values
sc1 and sc2 : equal values
...i'm just curios why the last 3 lines are the way they are.
INSIDE SETTER : same object
INSIDE SETTER : equal values
sc1 and sc2 : equal values
how come while inside the setter method, the objects are the same object, and after leaving the setter method are not the same objects?
Can anyone point a good book that shows in detail how objects, primitives and collections are referenced, especially when passed to methods. Online reference is preferred since the availability of books can be a problem for me.
Thanks very much

Answer 1

You are confusing references with objects.
This compares two object references:
if( obj1 == obj2 ) { // ...Whereas this compares two objects:
if( obj1.equals(obj2) ) { // ...A reference is a special value which indicates where in memory two objects happen to be. If you create two strings with the same value they won't be in the same place in memory:
String s1 = new String("MATCHING");
String s2 = new String("MATCHING");
System.out.println( s1 == s2 ); // false.But they do match:
System.out.println( s1.equals(s2) ); // trueIf you're using a primitive then you're comparing the value that you're interested in. E.g.
int x = 42;
int y = 42;
System.out.println(x == y); // trueBut if you're comparing references you're usually more interested in the objects that they represent that the references themselves.
Does that clarify matters?
Dave.