CS 46A - Lecture 24

Pre-class reading

• Sections 9.1 - 9.3

Final Exam

• December 17 12:15 - 14:30 in WSQ 109.
• I will design the final from three sources:
  • The problems tagged #practice that I've been suggesting for study in the last week or so
  • The homework assignments
  • The labs

  If it's not related to any of those, it won't be on the final.

• There will be three major themes:
  • Implementing methods in classes (such as the bugs)
  • Loops
  • Arrays and array lists
• Most of the questions will be "complete this code", but there will be one or two code tracing questions.
• The tutors will offer a workshop--see http://tinyurl.com/cs46ABtutorworkshop

Using Interfaces for Algorithm Reuse

• Use interface types to make code more reusable
• In Chapter 6, we created a DataSet to find the average and maximum of a set of numbers
• What if we want to find the bank account with the highest balance?

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

Using Interfaces for Algorithm 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
{
   private double sum;
   private Coin maximum;
   private int count;
   . . .
   public void add(Coin x)
   {
      sum = sum + x.getValue();
      if (count == 0 || maximum.getValue() < x.getValue())
         maximum = x;
      count++;
   }

   public Coin getMaximum()
   {
      return maximum;
   }
}

Using Interfaces for Algorithm Reuse

• The algorithm for the data analysis service 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 that the interface type requires

Syntax 9.1 Declaring an Interface

Interfaces vs. Classes

An interface type is similar to a class, but there are several important differences:

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

DataSet for Measurable Objects

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

   public Measurable getMaximum()
   {
      return maximum;
   }
}

Implementing an Interface Type

• Use implements reserved word to indicate that a class implements an interface type:

  public class BankAccount implements Measurable
  {
     ...
     public double getMeasure()
     {
        return balance;
     }
  }

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

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

Code Reuse

• A service type such as DataSet specifies an interface for participating in the service
• Use interface types to make code more reusable
• 

Syntax 9.2 Implementing an Interface

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
  

ch09/measure1/DataSetTester.java

ch09/measure1/DataSetTester.java

Program Run:

• Average balance: 4000.0
  Expected: 4000
  Highest balance: 10000.0
  Expected: 10000
  Average coin value: 0.13333333333333333
  Expected: 0.133
  Highest coin value: 0.25
  Expected: 0.25

Lecture 24 Clicker Question 1

Why can't the add method of the DataSet class have a parameter of type Object?

1. Because Object is a class, not an interface
2. Because Object does not have a getMeasure method
3. Because BankAccount doesn't implement Object
4. Because Object does not have a getBalance method

Lecture 24 Clicker Question 2

Suppose you want to use the DataSet class to find the Country object with the largest population. What condition must the Country class fulfill?

1. It must implement the Object interface
2. It must implement the Measurable interface
3. It must provide a getMeasure method that returns the country's population
4. Both 2 and 3

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 meas = account; // OK

• Coin dime = new Coin(0.1, "dime");
  Measurable meas = dime; // Also OK

• Cannot convert between unrelated types:

  Measurable meas = new Rectangle(5, 10, 20, 30); // ERROR

  Because Rectangle doesn't implement Measurable

Variables of Class and Interface Types

Casts

• Add Coin objects to DataSet:

  DataSet coinData = new DataSet();
  coinData.add(new Coin(0.25, "quarter"));
  coinData.add(new Coin(0.1, "dime"));
  coinData.add(new Coin(0.05, "nickel"));
  Measurable max = coinData.getMaximum(); // Get the largest coin

• What can you do with max? 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 doesn't refer to a Coin object, the program throws an exception and terminates
• Different from 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

Lecture 24 Clicker Question 3

Given the code

BankAccount acct = new BankAccount();
Coin dime = new Coin("dime", 0.1);
Measurable meas = new Coin("quarter", 0.25);

which of the following statements are correct?

1. acct = (BankAccount) meas;
2. dime = (Coin) meas;
3. acct = meas;
4. dime = meas;

Polymorphism

• An interface variable holds a reference to an object of a class that implements the interface:

  Measurable meas;
  meas = new BankAccount(10000);
  meas = new Coin(0.1, "dime");

  Note that the object to which meas 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 = meas.getMeasure();

• Which method is called?

Interface Reference

Polymorphism

• When the virtual machine calls an instance method, it locates the method of the implicit parameter's class — called dynamic method lookup
• If meas refers to a BankAccount object, then meas.getMeasure() calls the BankAccount.getMeasure method.
• If meas refers to a Coin object, then method Coin.getMeasure is called
• Polymorphism (many shapes) denotes the ability to treat objects with differences in behavior in a uniform way