Interfaces and Polymorphism

Chapter Goals

• To learn about interfaces
• To be able to convert between class and interface references
• To understand the concept of polymorphism
• To appreciate how interfaces can be used to decouple classes
• To learn how to implement helper classes as inner classes
• To understand how inner classes access variables from the surrounding scope
• To implement event listeners for timer events

Using Interfaces for Code Reuse

• Use interface types to make code more reusable
• In Chap. 7, we created a DataSet to find the average and maximum of a set of values (numbers)
• What if we want to find the average and maximum of a set of BankAccount values?

  public class DataSet // Modified for BankAccount objects
  {
     . . .
     public void add(BankAccount x)
     {
        sum = sum + x.getBalance();
        if (count == 0 || maximum.getBalance() < x.getBalance())
           maximum = x;
        count++;
     }
  
     public BankAccount getMaximum()
     {
        return maximum;
     }
  
     private double sum;
     private BankAccount maximum;
     private int count;
  }

Using Interfaces for Code Reuse

• Or suppose we wanted to find the coin with the highest value among a set of coins. We would need to modify the DataSet class again

  public class DataSet // Modified for Coin objects
  {
     . . .
     public void add(Coin x)
     {
        sum = sum + x.getValue();
        if (count == 0 || maximum.getValue() < x.getValue())
           maximum = x;
        count++;
     }
  
     public Coin getMaximum()
     {
        return maximum;
     }
  
     private double sum;
     private Coin maximum;
     private int count;
  }

Using Interfaces for Code Reuse

• The mechanics of analyzing the data is the same in all cases; details of measurement differ
• Classes could agree on a method getMeasure that obtains the measure to be used in the analysis
• We can implement a single reusable DataSet class whose add method looks like this:

  sum = sum + x.getMeasure();
  if (count == 0 || maximum.getMeasure() < x.getMeasure())
     maximum = x;
  count++;

• What is the type of the variable x?
  x should refer to any class that has a getMeasure method
• In Java, an interface type is used to specify required operations

  public interface Measurable
  {
     double getMeasure();
  }

• Interface declaration lists all methods (and their signatures) that the interface type requires

Interfaces vs. Classes

• All methods in an interface type are abstract; they don't have an implementation
• All methods in an interface type are automatically public
• An interface type does not have instance fields

Generic DataSet for Measurable Objects

public class DataSet
{
   . . .
   public void add(Measurable x)
   {
      sum = sum + x.getMeasure();
      if (count == 0 || maximum.getMeasure() < x.getMeasure())
         maximum = x;
      count++;
   }

   public Measurable getMaximum()
   {
      return maximum;
   }

   private double sum;
   private Measurable maximum;
   private int count;
}

Implementing an Interface Type

• Use implements keyword to indicate that a class implements an interface type

  public class BankAccount implements Measurable
  {
     public double getMeasure()
     {
        return balance;
     }
     // Additional methods and fields
  }

• A class can implement more than one interface type
  • Class must define all the methods that are required by all the interfaces it implements
• Another example:

  public class Coin implements Measurable
  {
     public double getMeasure()
     {
        return value;
     }
     . . .
  }

UML Diagram of DataSet and Related Classes

• Interfaces can reduce the coupling between classes
• UML notation:
  • Interfaces are tagged with a "stereotype" indicator «interface»
  • A dotted arrow with a triangular tip denotes the "is-a" relationship between a class and an interface
  • A dotted line with an open v-shaped arrow tip denotes the "uses" relationship or dependency
• Note that DataSet is decoupled from BankAccount and Coin
  

Syntax 11.1: Defining an Interface

public interface InterfaceName
{
   // method signatures
}

public interface Measurable
{
   double getMeasure();
}

Syntax 11.2: Implementing an Interface

public class ClassName
   implements InterfaceName, InterfaceName, ...
{
      // methods
      // instance variables
}

public class BankAccount implements Measurable
{
   // Other BankAccount methods
   public double getMeasure()
   {
      // Method implementation
   }
 }

File DataSetTester.java

   Average balance = 4000.0
   Highest balance = 10000.0
   Average coin value = 0.13333333333333333
   Highest coin value = 0.25

Self Check

1. Suppose you want to use the DataSet class to find the Country object with the largest population. What condition must the Country class fulfill?
2. Why can't the add method of the DataSet class have a parameter of type Object?

Answers

1. It must implement the Measurable interface, and its getMeasure method must return the population
2. The Object class doesn't have a getMeasure method, and the add method invokes the getMeasure method

Converting Between Class and Interface Types

• You can convert from a class type to an interface type, provided the class implements the interface
• BankAccount account = new BankAccount(10000);
  Measurable x = account; // OK
• Coin dime = new Coin(0.1, "dime");
  Measurable x = dime; // Also OK
• Cannot convert between unrelated types
  Measurable x = new Rectangle(5, 10, 20, 30); // ERROR
  Because Rectangle doesn't implement Measurable

Casts

• Add coin objects to DataSet
  DataSet coinData = new DataSet();
  coinData.add(new Coin(0.25, "quarter"));
  coinData.add(new Coin(0.1, "dime"));
  . . .
  Measurable max = coinData.getMaximum(); // Get the largest coin
• What can you do with it? It's not of type Coin
  String name = max.getName(); // ERROR
• You need a cast to convert from an interface type to a class type
• You know it's a coin, but the compiler doesn't. Apply a cast:
  Coin maxCoin = (Coin) max;
  String name = maxCoin.getName();
• If you are wrong and max isn't a coin, the compiler throws an exception
• Difference with casting numbers:
  When casting number types you agree to the information loss
  When casting object types you agree to that risk of causing an exception

Self Check

3. Can you use a cast (BankAccount) x to convert a Measurable variable x to a BankAccount reference?
4. If both BankAccount and Coin implement the Measurable interface, can a Coin reference be converted to a BankAccount reference?

Answers

3. Only if x actually refers to a BankAccount object.
4. No–a Coin reference can be converted to a Measurable reference, but if you attempt to cast that reference to a BankAccount, an exception occurs.

Polymorphism

• Interface variable holds reference to object of a class that implements the interface
  Measurable x;
  x = new BankAccount(10000);
  x = new Coin(0.1, "dime");
  Note that the object to which x refers doesn't have type Measurable; the type of the object is some class that implements the Measurable interface
• You can call any of the interface methods:
  double m = x.getMeasure();
• Which method is called?

Polymorphism

• Depends on the actual object. 
• If x refers to a bank account, calls BankAccount.getMeasure
• If x refers to a coin, calls Coin.getMeasure
• Polymorphism (many shapes): Behavior can vary depending on the actual type of an object
• Called late binding: resolved at runtime
• Different from overloading; overloading is resolved by the compiler (early binding)

Self Check

5. Why is it impossible to construct a Measurable object?
6. Why can you nevertheless declare a variable whose type is Measurable?
7. What do overloading and polymorphism have in common? Where do they differ?

Answers

5. Measurable is an interface. Interfaces have no fields and no method implementations.
6. That variable never refers to a Measurable object. It refers to an object of some class–a class that implements the Measurable interface.
7. Both describe a situation where one method name can denote multiple methods. However, overloading is resolved early by the compiler, by looking at the types of the parameter variables. Polymorphism is resolved late, by looking at the type of the implicit parameter object just before making the call.

Using Interfaces for Callbacks

• Limitations of Measurable interface:
  • Can add Measurable interface only to classes under your control
  • Can measure an object in only one way
    E.g., cannot analyze a set of savings accounts both by bank balance and by interest rate
• Callback mechanism: allows a class to call back a specific method when it needs more information
• In previous DataSet implementation, responsibility of measuring lies with the added objects themselves
• Alternative: Hand the object to be measured to a method:
  

  public interface Measurer
  {
     double measure(Object anObject);
  }

• Object is the "lowest common denominator" of all classes

Using Interfaces for Callbacks

• add method asks measurer (and not the added object) to do the measuring

  public void add(Object x)
  {
     sum = sum + measurer.measure(x);
     if (count == 0 || measurer.measure(maximum) < measurer.measure(x))
     maximum = x;
     count++;
  }

Using Interfaces for Callbacks

• You can define measurers to take on any kind of measurement
  

  public class RectangleMeasurer implements Measurer
  {
     public double measure(Object anObject)
     {
        Rectangle aRectangle = (Rectangle) anObject;
        double area = aRectangle.getWidth() * aRectangle.getHeight();
        return area;
     }
  }

• Must cast from Object to Rectangle
  Rectangle aRectangle = (Rectangle) anObject;
• Pass measurer to data set constructor:
  Measurer m = new RectangleMeasurer();
  DataSet data = new DataSet(m);
  data.add(new Rectangle(5, 10, 20, 30));
  data.add(new Rectangle(10, 20, 30, 40));
  . . .

UML Diagram of Measurer Interface and Related Classes

• Note that the Rectangle class is decoupled from the Measurer interface
  

File DataSet.java

File DataSetTester2.java

File Measurer.java

File RectangleMeasurer.java

   Average area = 616.6666666666666
   Maximum area rectangle = java.awt.Rectangle[x=10,y=20,width=30,height=40]

Self Check

8. Suppose you want to use the DataSet class of Section 11.1 to find the longest String from a set of inputs. Why can't this work?
9. How can you use the DataSet class of this section to find the longest String from a set of inputs?
10. Why does the measure method of the Measurer interface have one more parameter than the getMeasure method of the Measurable interface?

Answers

8. The String class doesn't implement the Measurable interface.
9. Implement a class StringMeasurer that implements the Measurer interface.
10. A measurer measures an object, whereas getMeasure measures "itself", that is, the implicit parameter.

Inner Classes

• Trivial class can be defined inside a method

  public class DataSetTester3
  {
     public static void main(String[] args)
     {
        class RectangleMeasurer implements Measurer
        {
           . . .
        }
        Measurer m = new RectangleMeasurer();
        DataSet data = new DataSet(m);
        . . .
     }
  }

• If inner class is defined inside an enclosing class, but outside its methods, it is available to all methods of enclosing class
• Compiler turns an inner class into a regular class file:
  DataSetTester$1$RectangleMeasurer.class

Syntax 11.3: Inner Classes

class OuterClassName
{
  method signature
  {
     . . .
     class InnerClassName
     {
        // methods
        // fields
     }
     . . .
  }
  . . .
}

class OuterClassName
{
   // methods
   // fields
   accessSpecifier class InnerClassName
   {
      // methods
      // fields
   }
   . . .
}

public class Tester
{
   public static void main(String[] args)
   {
      class RectangleMeasurer implements Measurer
      {
         . . .
      }
      . . .
   }
}

File DataSetTester3.java

Self Check

11. Why would you use an inner class instead of a regular class?
12. How many class files are produced when you compile the DataSetTester3 program?

Answers

11. Inner classes are convenient for insignificant classes. Also, their methods can access variables and fields from the surrounding scope.
12. Four: one for the outer class, one for the inner class, and two for the DataSet and Measurer classes.

Processing Timer Events

• javax.swing.Timer generates equally spaced timer events
• Useful whenever you want to have an object updated in regular intervals
• Sends events to action listener
  public interface ActionListener
  {
       void actionPerformed(ActionEvent event);
  }
• Define a class that implements the ActionListener interface
  class MyListener implements ActionListener
  {
       void actionPerformed(ActionEvent event)
     {
        // This action will be executed at each timer event
        Place listener action here
     }
  }
  
• Add listener to timer
  MyListener listener = new MyListener();
  Timer t = new Timer(interval, listener);
  t.start();

Example: Countdown

• Example: a timer that counts down to zero
  
• One second delay between printouts

File TimerTester.java

Self Check

13. Why does a timer require a listener object?
14. How many times is the actionPerformed method called in the preceding program?

Answers

13. The timer needs to call some method whenever the time interval expires. It calls the actionPerformed method of the listener object.
14. It depends. The method is called once per second. The first eleven times, it prints a message. The remaining times, it exits silently. The timer is only terminated when the user quits the program.

Accessing Surrounding Variables

• Methods of inner classes can access variables that are defined in surrounding scope
• Useful when implementing event handlers
• Example: Animation
  Ten times per second, we will move a shape to a different position

  class Mover implements ActionListener
  {
     public void actionPerformed(ActionEvent event)
     {
        // Move the rectangle
     }
  }
  
  ActionListener listener = new Mover();
  final int DELAY = 100; // Milliseconds between timer ticks
  Timer t = new Timer(DELAY, listener);
  t.start();

Accessing Surrounding Variables

• The actionPerformed method can access variables from the surrounding scope, like this:

  public static void main(String[] args)
  {
     . . .
     final Rectangle box = new Rectangle(5, 10, 20, 30);
  
     class Mover implements ActionListener
     {
        public void actionPerformed(ActionEvent event)
        {
           // Move the rectangle
           box.translate(1, 1);
        }
     }
     . . .
  }

• Local variables that are accessed by an inner-class method must be declared as final
• Inner class can access fields of surrounding class that belong to the object that constructed the inner class object
• An inner class object created inside a static method can only access static surrounding fields

File TimerTester2.java

Output

java.awt.Rectangle[x=6,y=11,width=20,height=30]
java.awt.Rectangle[x=7,y=12,width=20,height=30]
java.awt.Rectangle[x=8,y=13,width=20,height=30]
. . .
java.awt.Rectangle[x=28,y=33,width=20,height=30]
java.awt.Rectangle[x=29,y=34,width=20,height=30]
Last box position: java.awt.Rectangle[x=29,y=34,width=20,height=30]

Self Check

15. Why would an inner class method want to access a variable from a surrounding scope?
16. If an inner class accesses a local variable from a surrounding scope, what special rule applies?

Answers

15. Direct access is simpler than the alternative–passing the variable as a parameter to a constructor or method.
16. The local variable must be declared as final.

Operating Systems