Some Notes on Objects (cleaned up from Week 3 lecture)

0. Object and Reference

1. First, the term "object" needs to be clarified.  An "object" in Java technically consists of two entities: (1) an object, which is an instantiation of a class (created by 'new'), and (2) a reference to the object.  For example, a line

   String s1 = new String("abc");

    creates the following picture.

               

   A reference is said to "refer to" (or "point to") the object it points to.

    

2. Since a reference and an instantiated object are different entities, we can talk about references only, without instantiated objects.  But the terminology is still confusing because a reference, whether or not it points to an instantiated object, is declared with the type/class of the instantiated object (before an object is instantiated).

   For example, if we break the line above into 2 lines,

       String s1;

   At this point, we only have a reference.  This reference points to nowhere, that is, null.

    

   

   Then in the next line we instantiate an object by new.

       s1 = new String("abc");

   Now the picture becomes:

    

3. In computer memory, the object part is created in the heap, and the reference part is in the program/stack memory.

    

1. Objects are always created/instantiated by 'new'

• References are declared (not "created"), just like any other variables.  References are variables too.
• Objects are created/instantiated by 'new'.

  int x;      // int variable declared
  Mortgage m; // Mortgage reference variable declared
  
  m = new Mortgage(100000, 5.0, 30); // Mortgage object instantiated

2. Objects do not have to be destroyed/deallocated

• Since Java does the garbage collection, programmers do not have to destroy (instantiated) objects created in the heap.

  Mortgage m;
  
  do {
  
    m = new Mortgage(...); // Previously instantiated object becomes
                           // an orphan in heap, but it will be cleaned
                           // up due to Java's automatic garbage collection.  
  } while (...);

Scope Issue:

• Although a little unrelated, the following was discussed in the class.
• {  } creates a block (which has its own scope).  Variables declared inside the block are visible only inside the block.

  do {
  
    Mortgage m = new Mortgage(...); // m is declared inside do-while scope
  
  } while (...);
  
  System.out.println(m); // ERROR!! m is out of scope

3. Object equality vs. Reference equality

• Since a Java "object" involves two entities (a reference and an instantiated object), we have 2 notions of equality:
  • Object equality -- true if content of the two instantiated objects are the same; tested by ==
  • Reference equality -- true if two references refer to the same/one instantiated object; tested by .equals() method

  

• For user-defined classes, we can add a definition of equals() for the class. 
• The equals() method will be explained more in relation to Inheritance, but for now, you use the following signature, for ANY class you define yourself.

  public boolean equals(Object obj);

  For instance, here is an example equals() method for Mortgage:

  class Mortgage
  {
    // fields
    private double amount;
    private double rate;
    private int years;
  
    // methods
    public Mortagage() {..}
    ...
    public boolean equals(Object obj)
    {
      if (obj instanceof Morgage)  // if parameter obj is of type Mortage
      {
        Mortgage mo = (Mortgage) obj;  // type-cast obj to Morgage
        return (this.amount == mo.amount && // private access in mo is ok
                this.rate == mo.rate &&     // because mo is Mortage too 
                this.years == mo.years);    // (by type-casting above).
      }
      else
        return false;  // false if comparing with object of other type
    }
  }