To appreciate how interfaces can be used to decouple classes
Using Interfaces for Algorithm Reuse
Interface types are used to express common operations
Interfaces make it possible to make a service available to a wide set
This restaurant is willing to serve anyone who conforms to the Customer interface with eat and pay methods
Defining an Interface Type
Example: a method to compute the average of an array of Objects
The algorithm for computing the average is the same in all cases
Details of measurement differ
Goal: write one method that provides this service
We can't call getBalance in one case and getArea in another
Solution: all object who want this service must agree on a getMeasure method
BankAccount's getMeasure will return the balance
Country's getMeasure will return the area
Now we implement a single average method that computes the sum
sum = sum + obj.getMeasure();
Defining an Interface Type
Problem: we need to declare a type for obj
Need to invent a new type that describes any class whose objects can be measured
An interface type is used to specify required operations (like getMeasure)
public interface Measurable
{
double getMeasure();
}
A Java interface
type declares
methods but does
not provide their
implementations
Syntax 10.1 Declaring an Interface
Defining an Interface Type
An interface type is similar to a class
Differences between classes and interfaces
An interface type does not have instance variables.
All methods in an interface type are abstract
They have a name, parameters, and a return type, but no implementation.
All methods in an interface type are automatically public.
An interface type has no constructor.
You cannot construct objects of an interface type.
Defining an Interface Type
Implementing a reusable
average method
public static double average(Measurable[] objects)
{
double sum = 0;
for (Measurable obj : objects)
{
sum = sum + obj.getMeasure();
}
if (objects.length > 0) { return sum / objects.length; }
else { return 0; }
}
This method is can be used for objects of any class that
conforms to the Measurable type.
This stand-mixer provides the “rotation”
service to any attachment that
conforms to a common interface.
Similarly, the average method at the
end of this section works with any class
that implements a common interface
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;
}
}
BankAccount objects are instances of the Measurable type
Measurable obj = new BankAccount(); // OK
Implementing an Interface Type
A variable of type Measurable holds a reference to an object of some class that implements the Measurable interface.
Country class can also implement the Measurable interface
public class Country implements Measurable
{
public double getMeasure()
{
return area;
}
. . .
}
Use interface types to
make code
more reusable.
Implementing an Interface Type
Put the average method in a class - say Data
UML Diagram of the
Data Class and
the Classes that
Implement the
Measurable Interface
Data class is decoupled from the BankAccount and Country classes
Returns the object with the larger measure, as a Measurable reference.
Country uruguay = new Country("Uruguay", 176220);
Country thailand = new Country("Thailand", 513120);
Measurable max = larger(uruguay, thailand);
Casting from Interfaces to Classes
You know that max refers to a Country object, but the compiler does not
Solution: cast
Country maxCountry = (Country) max;
String name = maxCountry.getName();
You need a cast to convert from an interface type to a class type
If you are wrong and max doesn't refer to a Country object, the program throws an exception at runtime
If a Person object is actually a Superhero, you need a cast before you can apply any Superhero methods
Question 1 May 13
Can you use a cast (Country) meas to convert a Measurable
variable meas to a Country reference? (Country implements Measurable)
Yes, always
No, never
Yes if meas actually refers to a Country object.
Self Check 10.7
If both BankAccount and Country implement the Measurable
interface, can a Country reference be converted to a BankAccount
reference?
Answer:
No — a Country reference can be converted to a Measurable
reference, but if you attempt to cast that reference to a BankAccount,
an exception occurs.
Question 2 May 13
Which code below will construct a Measurable object?
Measurable thing;
Measurable thing = new Measurable();
Measurable thing = new Rectangle();
You can not create a Measurable object.
Self Check 10.9
Why can you nevertheless declare a variable whose type is Measurable?
Answer:
That variable never refers to a Measurable
object. It refers to an object of some class—a
class that implements the Measurable interface.
Self Check 10.10
What does this code fragment print? Why is this an example of polymorphism?
Measurable[] data = { new BankAccount(10000), new Country("Belgium", 30510) };
System.out.println(average(data));
Answer:
The code fragment prints 20255. The average
method calls getMeasure on each object in the
array. In the first call, the object is a BankAccount.
In the second call, the object is a Country. A different
getMeasure method is called in each case.
The first call returns the account balance, the
second one the area, which are then averaged.
The Comparable Interface
Comparable interface is in the standard Java library
Comparable interface has a single method
public interface Comparable
{
int compareTo(Object otherObject);
}
The call to the method
a.compareTo(b)
The compareTo method returns
a negative number if a should come before b,
zero if a and b are the same
a positive number if b should come before a.
Implement the
Comparable interface
so that objects
of your class can
be compared, for
example, in a
sort method.
The Comparable Interface
BankAccount class' implementation of Comparable
public class BankAccount implements Comparable
{
. . .
public int compareTo(Object otherObject)
{
BankAccount other = (BankAccount) otherObject;
if (balance < other.balance) { return -1; }
if (balance > other.balance) { return 1; }
return 0;
}
. . .
}
compareTo method has a parameter of reference type Object
To get a BankAccount reference
BankAccount other = (BankAccount) otherObject;
The Comparable Interface
Because the BankAccount class implements the Comparable interface, you can sort an array
of bank accounts with the Arrays.sort method
BankAccount[] accounts = new BankAccount[3];
accounts[0] = new BankAccount(10000);
accounts[1] = new BankAccount(0);
accounts[2] = new BankAccount(2000);
Arrays.sort(accounts);
Now the accounts array is sorted by increasing balance.
The compareTo method checks whether another object is larger or smaller
Self Check 10.11
How can you sort an array of Country objects by increasing area?
Answer:
Have the Country class implement the Comparable interface, as shown below, and call Arrays.sort.
public class Country implements Comparable
{
. . .
public int compareTo(Object otherObject)
{
Country other = (Country) otherObject;
if (area < other.area) { return -1; }
if (area > other.area) { return 1; }
return 0;
}
}
Self Check 10.12
Can you use the Arrays.sort method to sort an array of String objects? Check the API documentation for the String class.
Answer:
Yes, you can, because String implements the Comparable interface type.
Self Check 10.13
Can you use the Arrays.sort method to sort an array of Rectangle objects? Check the API documentation for the Rectangle class.
Answer:
No. The Rectangle class does not implement the Comparable interface.
Self Check 10.14
Write a method max that finds the larger of any two Comparable objects
Answer:
public static Comparable max(Comparable a, Comparable b)
{
if (a.compareTo(b) > 0) { return a; }
else { return b; }
}
Self Check 10.15
Write a call to the method of Self Check 14 that computes the larger of two bank accounts, then prints its balance.
public class MeasurerTester
{
public static void main(String[] args)
{
class AreaMeasurer implements Measurer
{
. . .
}
. . .
Measurer areaMeas = new AreaMeasurer();
double averageArea = Data.average(rects, areaMeas);
. . .
}
}
An inner class is a class that is declared inside another class.
Inner Classes
You can declare inner class inside an enclosing class, but outside its methods
It
is available to all methods of enclosing class:
public class MeasurerTester
{
class AreaMeasurer implements Measurer
{
. . .
}
public static void main(String[] args)
{
Measurer areaMeas = new AreaMeasurer();
double averageArea = Data.average(rects, areaMeas);
. . .
}
}
Compiler turns an inner class into a regular class file with a strange name
MeasurerTester$1AreaMeasurer.class.
Inner classes are
commonly used for
utility classes that
should not be
visible elsewhere
in a program.
Self Check 10.21
Why would you use an inner class instead of a regular class?
Answer:
Inner classes are convenient for insignificant
classes. Also, their methods can access local
and instance variables from the surrounding
scope.
Self Check 10.22
When would you place an inner class inside a class but outside any methods?
Answer:
When the inner class is needed by more than
one method of the classes.
Self Check 10.23
How many class files are produced when you compile the MeasurerTester program from this section?
Answer: Four: one for the outer class, one for the inner
class, and two for the Data and Measurer
classes.
Mock Objects
Problem: Want to test a class before the entire program has been completed
A mock object provides the same services as another object, but in a simplified manner
If you just want to practice arranging the Christmas
decorations, you don’t need a real tree. Similarly,
when you develop a computer program, you can
use mock objects to test parts of your program.
Mock Objects
Example: a grade book application, GradingProgram, manages quiz scores using class GradeBook with methods:
public void addScore(int studentId, double score)
public double getAverageScore(int studentId)
public void save(String filename)
Want to test GradingProgram without having a fully functional GradeBook class
Declare an interface type with the same methods that the GradeBook class provides
Convention: use the letter I as a prefix for the interface name
Both the mock class
and the actual class
implement the
same interface.
The GradingProgram class should only use this interface, never the GradeBook class which implements this interface
Meanwhile, provide a simplified mock implementation, restricted to the case of one student and without saving functionality:
public class MockGradeBook implements IGradeBook
{
private ArrayList<Double> scores;
public MockGradeBook() { scores = new ArrayList<Double>(); }
public void addScore(int studentId, double score)
{
// Ignore studentId
scores.add(score);
}
public double getAverageScore(int studentId)
{
double total = 0;
for (double x : scores) { total = total + x; }
return total / scores.size();
}
public void save(String filename)
{
// Do nothing
}
. . .
}
Mock Objects
Now construct an instance of MockGradeBook and use it immediately to test the GradingProgram class
When you are ready to test the actual class, simply use a GradeBook instance instead
Don’t erase the mock class — it will still come in handy for regression testing
Self Check 10.24
Why is it necessary that the real class and the mock class implement the same interface type?
Answer:
You want to implement the GradingProgram class in terms of that interface so that it doesn’t have to change when you switch between the mock class and the actual class.
Self Check 10.25
Why is the technique of mock objects particularly effective when the GradeBook and GradingProgram class are developed by two programmers?
Answer:
Because the developer of GradingProgram doesn’t have to wait for the GradeBook class to be complete.
Event Handling
In an event-driven user interface,
the program receives an event
whenever the user manipulates
an input component.
User interface events include key presses, mouse moves, button clicks,
and so on
Most programs don't want to be flooded by irrelevant events
A program must indicate which events it needs to receive
Event Handling
Event listeners:
A program indicates which events it needs to receive by installing event listener objects
Belongs to a class provided by the application programmer
Its methods describe the actions to be taken when an event occurs
Notified when event happens
Event source:
User interface component that generates a particular event
Add an event listener object to the appropriate event source
When an event occurs, the event source notifies all event listeners
Events Handling
Example: A program that prints a message whenever a button is clicked:
Button listeners
must belong to a class that implements the ActionListener interface:
public interface ActionListener
{
void actionPerformed(ActionEvent event);
}
Your job is to supply
a class whose actionPerformed method contains the instructions that you want executed
whenever the button is clicked.
Whenever a button is pressed, the actionPerformed method is called on all listeners.
Specify button
click actions
through classes
that implement
the ActionListener interface.
Using Inner Classes for Listeners
Implement simple listener classes as inner classes like this:
JButton button = new JButton(". . .");
// This inner class is declared in the same method as the button variable
class MyListener implements ActionListener
{
. . .
}
ActionListener listener = new MyListener();
button.addActionListener(listener);
Advantages
Places the trivial listener class exactly where it is needed, without
cluttering up the remainder of the project
Methods of an inner class can access instance variables and methods of from surrounding class:
Using Inner Classes for Listeners
Local variables that are accessed by an inner class method must be declared as final
Example: add interest to a bank account whenever a button is
clicked:
JButton button = new JButton("Add Interest");
final BankAccount account = new BankAccount(INITIAL_BALANCE);
// This inner class is declared in the same method as the account and button variables.
class AddInterestListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
// The listener method accesses the account variable
// from the surrounding block
double interest = account.getBalance() * INTEREST_RATE / 100;
account.deposit(interest);
}
};
ActionListener listener = new AddInterestListener();
button.addActionListener(listener);
Answer:
The timer needs to call some method whenever the time interval expires. It calls
the actionPerformed method of the listener object.
Self Check 10.34
What would happen if you omitted the call to repaint in the moveBy method?
Answer:
The moved rectangles won't be painted, and the rectangle will appear to be
stationary until the frame is repainted for an external reason.
Mouse Events
Use a mouse listener to capture mouse events
Implement the MouseListener interface which has five methods:
public interface MouseListener
{
void mousePressed(MouseEvent event);
// Called when a mouse button has been pressed on a component
void mouseReleased(MouseEvent event);
// Called when a mouse button has been released on a component
void mouseClicked(MouseEvent event);
// Called when the mouse has been clicked on a component
void mouseEntered(MouseEvent event);
// Called when the mouse enters a component
void mouseExited(MouseEvent event);
// Called when the mouse exits a component
}
Mouse Events
Add a mouse listener to a component by calling the addMouseListener
method:
public class MyMouseListener implements MouseListener
{
// Implements five methods
}
MouseListener listener = new MyMouseListener();
component.addMouseListener(listener);
Sample program: enhance RectangleComponent –
when user clicks on rectangle component, move the rectangle
to the mouse location
First add a moveRectangle method to RectangleComponent
Mouse Events
Call repaint to tell the component to repaint itself and show the rectangle in its new position
When the mouse is pressed,the mouse listener moves the rectangle to the
mouse location:
class MousePressListener implements MouseListener
{
public void mousePressed(MouseEvent event)
{
int x = event.getX();
int y = event.getY();
component.moveTo(x, y);
}
// Do-nothing methods
public void mouseReleased(MouseEvent event) {}
public void mouseClicked(MouseEvent event) {}
public void mouseEntered(MouseEvent event) {}
public void mouseExited(MouseEvent event) {}
}
All five methods of the interface must be implemented; unused methods can be
empty
This stand-mixer provides the “rotation”
service to any attachment that
conforms to a common interface.
Similarly, the average method at the
end of this section works with any class
that implements a common interface
