Lecture Summary 4

Classes and Interfaces

• Primitive types vs. reference types
  • Variables and objects
    • Variables of primitive types hold the values of the primitive types directly.
    • Variables of reference types hold references (pointers) to objects, which resides in the garbage-collected heap.
      Recall that an object variable and an object are two separate things. Even though we can build an object in one single statement, we actually first declare the reference variable and then create an object for it to refer to. The reference vriable hold the address of an object. When we use the dot operator to invoke an object's method, we are actually using the address in the reference variable to locate the object in memory.
      
  • Garbage collection
    • Programmers are not responsible for deallocating memory.
    • When an object is no longer accessible from any where (has no reference to it) in the program, it becomes garbage.
    • The garbage-collector in the Java virtual machine automatically reclaims the memory occupied by garbages.
    • public void finalize()
      • can be defined by the programmer and invoked by the Java runtime just before the object is garbage-collected
    • System.gc()
      • suggest to the Java virtual machine to do a garbage-collection
    
    
  • Null reference
    • null
    • A reference does not refer to any object. For example when a reference variable is initially declared, it is a null reference. We can also explicitly set a reference to null.
    • The followings are not the same:
      • String s1 = null;
      • String s2 = "";
    
    
  • Alias of objects
    • two or more reference variables refer to the same object. An assignment operator applied to two referece variables that refere to two different objects, the value of the reference from the right hand-side object gets copied to the one on the left hand-side. So, both reference variables now refer to the same object and all references to the object that got assigend the new reference are gone and cannot be used.
  
  
• Parameter passing
  • Parameters in a Java method are passed by value
  • The actual parameters (the values passed in) are assigned to the formal parameters (declared in the method header)
    • For parameters of primitive types, the formal parameter is a copy of the actual parameter.
    • For parameters of reference types (objects), the formal parameter is an alias of the actual parameter. Thus, changes made to the object (in the called method) through the reference will be refelected in the calling method.
    
    
  • Example:  Num.java,  ParameterTester.java,   ParameterPassing.java  
  
  
• The this reference
  • It allows an object to refer to itself. Recall that a method is invoked through a particular object or class. Inside that method, the this reference can be used to refer to the object through which the method was invoked.
  • Why would you want to do this?
    Typically, within an object's method body we can just refer to the object's member variables by name. However, sometimes a member variable is hiden by a method parameter that has the same name.
  
  Example:

         public class Point
         {
            public double x, y;
            public Point()
            {}
            public Point(double x, double y)
            {
               // the parameters x and y are simply the initial
               // values of field x and y of class Point
               this.x =x;
               this.y =y;
            }
            public void adjustPosition(....)
            {
               x = this.x;
               y = this.y;
                     // do calculation using the local x and y
               ...
                     // commit the changes when done
               this.x = x;
               this.y = y;
            }
            // ... other methods
         }
  

  
  
• The static modifier  (Review and more)
  • Static fields and methods are associated with their class rather than their object
  • Static methods can only use the static fields of the class.
  • Static fields are per class, instead of per instance.
  • Static methods can only use the static fields of the class.
  • Static fields and static methods can be used without creating instances of the class:
    ClassName.staticField
    ClassName.staticMethod(parameters, ...)
  • Static fields are shared among all the instances of the class.
  • Examples seen so far:
    • The methods of Math and Keyboard classes are static, that why we invoke them using class name (without instantiating any object of the class):
      System.out.println ("Square root of 27: " + Math.sqrt(27));
      int value = Keyboard.readInt();
  • Static fields can be initialized in a static block: 
    public class MyClass {
      private static int value;

      static {
        value = ...;
      }
      // ...
    }

  • A local variable cannot be static.
  • A static method cannot use a non-static variable. Therefore, the main method can access only static or local variable.
  
  
• Example:   CountInstances.java,  MyClass.java,  




• Inner class
  • A non-static class nested inside another class.
  • An inner class has access to the variables and methods of the outer class, even if they are declared private, because it is considered a member of the enclosing class.
  • The name of the byte-code file of the nested class is the name of the outer class followed by $ character followed by the name od the nested class.
  • An inner class is associated with each instance of the outer class
  • Inner classes can be protected by the outer class from external use.
  • No member inside the inner class can be declared static.
  • Intended for small helper classes of the outer class.
  
  
• Interfaces
  • A Java interface consists of declarations of abstract methods and constants.
  • An abstract method declaration is a method header without a method body.
  • An interface defines a contact without an implementation.
  • An interface cannot be instantiated, since it has no implementation.
  • Interfaces are to be implemented by classes. A class that implements an interface is responsible for providing implementations of all the abstract methods declared in the interface.
  • An interface provides a client's view of a software component, and a class implementing the interface provides the implementer's view of the software component.
    
  • Examples from Java standard class library:

      public interface Comparable
      {
         // Compares the executing object to the parameter
         // returns relative ordering as integer <0, =0, or >0
    
         public int compareTo(Object o);
      }
    
      public interface Iterator
      {
         // return true if executing object has one or more objects
         // that have not been returned by next method yet.
         public boolean hasNext();
    
         // return a reference to the next object in the iterator
         public Object next();
    
         //remove item most recently returned by next method from the collection
         public void remove();
      }
    

• Examples from the text:
  Speaker.java,  Philosopher.java,   Dog.java, 


• Polymorphism via Interfaces
  • An interface reference can refer to any object of any class that implements the interface.
  • The reference variable current in the following declaration can be used to refer to a Dog object or Philosopher.
  • When current object invokes a method, it is the type of the object that determines which method implementation is invoked.
  • Example:
    Talking.java, 
  
  

  class Talking
  {
  
     //  reference into a class reference to invoke its unique method.
  
     public static void main (String[] args)
     {
        // declare an interface reference
        Speaker current;
  
        // instantiates a Dog object using the interface reference
        current = new Dog();
  
        //  invokes one of the common methods
        current.speak();
  
        // instantiates a philosopher object using the interface reference
        current = new Philosopher ("I think, therefore I am."); //---> line (*)
  
        //  invokes the common method
        current.speak();
  
        // casts the interface to make the Speaker a Philosopher
        ((Philosopher) current).pontificate();
     }
  }
  

  Note that we cannot just use th dot operator between current and this method, because current is of type Speaker not Philosopher while this method is a member of Philosopher class. Remember, every Philosopher is a Speaker, but not every Speaker is Philosopher. The line (*) makes current a philosopher Speaker, but not a complete Philosopher whcih can invoke any method in Philosopher class. That why the casting is needed.