Lecture Summary 4a

• 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.

       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 
       }         

• 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.

• 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.

• 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(); 
    } 
  

• 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.

Applet (continued)

• Applet methods
  • public void paint(Graphics g) // draw contents of applet on screen
  • public void init() // executed once when applet fist loaded. Good place to initialize applet's environment and data.
  • public void start() // called when applet becomes active.
    Every applet must implement at least one of the above: init, start or paint.
    
    
  • public void stop() // called when applet becomes inactive.
  • public void destroy() // called when browser is exited to destroy applet.
  • public URL getCodeBase() // returns URL at which this applet's bytecode is located
  • public URL getDocumentBase() // returns URL of the HTML document containing this applet
  • public AudioClip getAudioClip(URL url, String name) // get an AudioClip from the URL
  • public Image getImage(URL url, String name) // receives image from the URL

• Example:
  LineUp.java,     LineUp.html