1. Big Java
Chapters 9-10

2. Interfaces for Code Reuse
Interface specifies common set of operations
All methods are abstract (like prototypes), no implementation. Must be public.
Interface may have constants, but no instance fields (never instantiate an interface directly)
Other classes can then implement that interface

3. Interface Example public interface Measureable { public class Coin
double getMeasure(); }
public class Coin
implements Measurable {
public double getMeasure()
return value; }
. . .
keyword public required, default is package
public class BankAccount implements Measurable {
public double getMeasure()
return balance; }
. . .
Can implement more than
one interface!

4. Interface Example, continued
public class DataSet {
public void add(Measurable x)
sum = sum + x.getMeasure();
if (count == 0 || max.getMeasure() < x.getMeasure())
max = x;
count++; }
public Measureable getMaximum()
return max;
private double sum;
private Measurable max;
private int count;

5. Interface Example, continued
BankAccount account = new BankAccount(1000);
Measurable x = account; // OK to convert
Coin dime = new Coin(0.1, “dime”);
x = dime; // Also OK – notice we don’t know type of
// x, just that it implements Measurable, so it is
// OK to call getMeasure. May do cast if you are
// sure of the type
DataSet coinData = new DataSet();
coinData.add(new Coin(0.25, “quarter”);
Measurable max = coinData.getMaximum();
String coinName = max.getName(); // Error
Coin maxCoin = (Coin) max; // Error if you’re wrong!
String coinName = max.getName();
Measurable x = new Rectangle(5, 10, 20, 20); //not OK

6. Polymorphism How is correct method executed?
Measurable x = new BankAccount(1000);
double m = x.getMeasure();
x = new Coin(0.1, “dime”);
m = x.getMeasure();
JVM locates correct method. What did we do in C++?
Overloading method – early binding (e.g., default vs 1-parameter constructor; static)
Polymorphism – late binding (dynamic)

7. <<interface>>
UML Diagram
BankAccount
Coin
is-a
(triangular tip)
stereotype
indicator
<<interface>>
Measurable
DataSet
uses
(open arrow tip)

8. Design Idea: Callbacks
Limitations to Measurable Interface:
Can only add Measurable interface to classes under your control (so can only have DataSet of those classes… e.g., no DataSet of Rectangles)
You can only measure an object in one way, because only one getMeasure function. What if you need two measures? (e.g., by balance and interest rate, for a savings account)

9. Callbacks (continued)
Instead of Measurable, add Measurer interface
Method measure takes an Object (parent of all other classes) and returns that object’s “measure”
The “callback” is the method “measure” which DataSet can call when it needs information
The implementation of measure will vary based on the underlying data type

10. Callback DataSet Example
public interface Measurer {
double measure(Object anObject; }
public class DataSet {
public void add(Object x)
sum += measurer.measure(x);
if (count == 0 ||
measurer.measure(max) < measurer.measure(x))
max = x;
count++; }

11. CallBack DataSet (continued)
public class RectangleMeasurer implements Measurer {
public double measure(Object anObject)
Rectangle aRect = (Rectangle) anObject);
double area = aRect.getWidth() * aRect.getHeight();
return area; }
Measurer m = new RectangleMeasurer();
DataSet data = new DataSet(m);
data.add(new Rectangle(5, 10, 20, 20));
. . .

12. <<interface>>
UML Diagram
Rectangle
Measurer
Rectangle
is-a
(triangular tip)
<<interface>>
Measurer
DataSet
uses
(open arrow tip)

13. Reading Assignment
Read the Wikipedia entry for Callback Functions

14. Inner Classes
A trivial class that is only needed to provide functionality to the enclosing (outer) class
C++ has nested classes, but Java provides access to enclosing class variables, which is convenient
class OuterClassName {
method signature
. . .
class InnerClassName
methods
fields }
class OuterClassName {
methods
fields
access class InnerClassName }
creates class files with $ in names

15. More GUI Programming
GUIs are under control of the user, not the program
Java programs react to a wide variety of user interface events – button pushes, mouse clicks, window manipulation, etc.
Program installs event listeners for events of interest
Need to know the event source – e.g., button, text box, window etc.
All listeners implement the particular interface for that type of event (e.g., button listeners must implement ActionListener)

16. Simple Button Example import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
An action listener that prints a message. */
public class ClickListener implements ActionListener {
public void actionPerformed(ActionEvent event)
System.out.println("I was clicked."); }
method signature must be exact!

17. Simple Button Example (continued)
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
This program demonstrates how to install an action listener. */
public class ButtonViewer {
public static void main(String[] args)
JFrame frame = new JFrame();
JButton button = new JButton("Click me!");
frame.add(button);
ActionListener listener = new ClickListener();
button.addActionListener(listener);
frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true); }
private static final int FRAME_WIDTH = 100;
private static final int FRAME_HEIGHT = 60;

18. Inner Classes as Button Listeners
import java.awt.event.*;
import javax.swing.*;
public class InvestmentViewer1 {
public static void main(String[] args)
JFrame frame = new JFrame();
JButton button = new JButton("Add Interest");
frame.add(button);
// The application adds interest to this bank account
final BankAccount account = new BankAccount(INITIAL_BALANCE);
class AddInterestListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
// The listener accesses variable from surrounding block
double interest = account.getBalance()*INT_RATE / 100;
account.deposit(interest);
System.out.println("balance: " + account.getBalance()); }
ActionListener listener = new AddInterestListener();
button.addActionListener(listener);
. . .normal frame code here
… constants defined here

19. More GUI Classes and Details
JPanel – container used to organize your program layout
JLabel – provides a text description
frame.getContentPane().add(aComponent) is the same as frame.add(aComponent) – getContentPane was needed in earlier versions of Java
Don’t use a container as a listener
may have more than one button etc.
separates button definition from button action

20. On Your Own
Read 9.9 Processing Timer Events and 9.10 Mouse Events

21. On to Chapter 10…
Inheritance

22. Inheritance Basics Models “is-a” relationship, same as C++
requires extends keyword
All classes are children of class Object
Object has several methods that are frequently overridden:
toString: returns a string that describes the state of the object, automatically called by System.out.println(objectRef);
clone: creates a deep copy of an object
equals: does a field-by-field comparison, returns boolean result

23. Simple Inheritance Example
class SavingsAccount extends BankAccount {
public SavingsAccount(double balance, double rate)
super(balance); // calls parent constructor
interestRate = rate; }
void addInterest()
// use getters/setters unless protected
double interest = getBalance() * interestRate / 100;
deposit(interest);
private double interestRate;

24. UML for Inheritance Object should be “hollow triangle” tip BankAccount
SavingsAccount

25. Can have Inheritance Hierarchy
JComponent
JPane
JTextComponent
JLabel
AbstractButton
JToggleButton
JButton
JTextField
JTextArea
JCheckBox
JRadioButton

26. More on Inheritance OK – but what will it contain?
SavingsAccount collegeFund = new SavingsAccount(1000, 0.1);
BankAccount anAccount = collegeFund;
Object anObject = collegeFund;
collegeFund.addInterest; // OK
anAccount.addInterest; //not OK
String aString = anObject.toString();
OK – but what will it contain?

27. Typecasts
If you know that a reference contains a specific type of object, you can perform a cast (will be an exception if you’re wrong)
BankAccount myAccount = (BankAccount) anObject;
Can use instanceof to test class type
if (anObject instanceof BankAccount) { … }

28. Polymorphism
In Java, method calls are always determined by the type of the actual object, not the type of the object reference (unlike C++, where virtual keyword is needed)

29. Abstract Classes
Concept same as C++, use in same types of situations (i.e., force subclasses to define behavior
Requires use of abstract keyword
As in C++, you can’t initialize objects of an abstract type
public abstract class BankAccount {
public abstract void deductFees();
. . . }
BankAccount anAccount;
anAccount = new BankAccount(); // ERROR
anAccount = new SavingsAccount(); // OK (deductFees defined)

30. Final Methods and Classes
May occasionally want to prevent others from creating subclasses or overriding methods
public final class String { }
public final boolean checkPassword(String password) { }

31. Access control public – like C++, good for constants
private – like C++, good for instance fields
protected – like C++ but extends to package, convenient for inheritance
package
all methods of classes in the same package have access
this is the default! (easy to forget)
OK if several classes in package collaborate, but generally inner classes are better, packages are not secure (anyone can add a class to the package)
public class BankAccount {
double balance; // package access
. . . }

32. Object Method Examples – toString
public class BankAccount {
public String toString() {
return getClass().getName() + balance; }
. . .
public class SavingsAccount
return super.toString + “ Rate” +
interestRate;
class object describes
class & properties
call to parent class

33. Object Method Examples – equals
public boolean equals(Object otherObject) {
if (otherObject == null) return false;
if (getClass() != otherObject.getClass())
return false;
BankAccount account = (BankAccount) otherObject;
return balance == account.balance;
// should call super.equals first if you write an
// equals for a subclass
// instanceof sometimes used, but it would return
// true for a subclass }
What happens if you don’t override equals?

34. Quality Tip 10.1 Clone mutable instance fields in accessor methods
public class Customer {
public Customer(String aName) {
name = aName;
account = new BankAccount(); }
public String getName() {
return name;
public BankAccount getAccount()
return account
private String name;
private BankAccount account;
Customer harry = new
Customer(“Harry”);
BankAccount acct =
harry.getAccount();
account.withdraw(10000);

35. Object Method Examples – clones
Read advanced topic 10.6 if you need to write a clone method

36. GUIs with Inheritance and TextField
import java.awt.event.*;
import javax.swing.*;
public class InvestmentFrame extends JFrame {
public InvestmentFrame()
account = new BankAccount(INITIAL_BALANCE);
resultArea = new JTextArea(AREA_ROWS, AREA_COLUMNS);
resultArea.setEditable(false);
// Use helper methods
createTextField();
createButton();
createPanel();
setSize(FRAME_WIDTH, FRAME_HEIGHT); }

37. GUIs with Inheritance and TextField
private void createTextField() {
rateLabel = new JLabel("Interest Rate: ");
final int FIELD_WIDTH = 10;
rateField = new JTextField(FIELD_WIDTH);
rateField.setText("" + DEFAULT_RATE); }

38. GUIs with Inheritance and TextField
private void createButton() {
button = new JButton("Add Interest");
class AddInterestListener implements ActionListener
public void actionPerformed(ActionEvent event)
double rate = Double.parseDouble(
rateField.getText());
double interest = account.getBalance()
* rate / 100;
account.deposit(interest);
resultArea.append(account.getBalance() + "\n"); }
ActionListener listener = new AddInterestListener();
button.addActionListener(listener);

39. GUIs with Inheritance and TextField
private void createPanel() {
panel = new JPanel();
panel.add(rateLabel);
panel.add(rateField);
panel.add(button);
JScrollPane scrollPane = new JScrollPane(resultArea);
panel.add(scrollPane);
add(panel); }

40. GUIs with Inheritance and TextField
private JLabel rateLabel;
private JTextField rateField;
private JButton button;
private JTextArea resultArea;
private JPanel panel;
private BankAccount account;
private static final int FRAME_WIDTH = 400;
private static final int FRAME_HEIGHT = 250;
private static final int AREA_ROWS = 10;
private static final int AREA_COLUMNS = 30;
private static final double DEFAULT_RATE = 5;
private static final double INITIAL_BALANCE = ; }

41. GUIs with Inheritance and TextField
import javax.swing.JFrame;
/**
This program displays the growth of an investment. */
public class InvestmentViewer4 {
public static void main(String[] args)
JFrame frame = new InvestmentFrame();
frame.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE);
frame.setVisible(true); }

42. Exercise Design and implement a GUI for an application that includes:
An ArrayList of BankAccount objects
Actual objects may be either SavingsAccount or CheckingAccount
User should be able to create new accounts or maintain existing accounts (withdraw/deposit etc.)
Add extra methods/fields to BankAccount classes as you see fit