1. CS 151: Object-Oriented Design October 8 Class Meeting
Department of Computer Science San Jose State University Fall 2013 Instructor: Ron Mak

2. The Java Interface as a Contract
public interface HouseholdPet {
void feed(Food f); }
Any class that implements an
interface is guaranteed to
implement each and every one
of the interface methods.
public interface ActionListener { void actionPerformed(ActionEvent event); }
public interface Icon { int getIconWidth(); int getIconHeight(); void paintIcon(Component c, Graphics g, int x, int y); }
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

3. Review: Design Patterns
A design pattern is
A description of a problem.
A solution that you can apply to many programming situations.
Design patterns show you how to build good software with good object-oriented design qualities.
Design patterns are proven object-oriented experience.
Design patterns are not code, but are general solutions to design problems.
You apply them to your specific application.
Design patterns are not invented – they’re discovered.
Design patterns address how to manage change.
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

4. Review: The Factory Method Design Pattern
Context
An application can instantiate any one of several subclasses of a superclass (or any one of several implementers of an interface).
Description
You know that your application needs to instantiate one of the subclasses.
But you won’t know which subclass until run time.
You need to provide a means to instantiate the subclass as determined by the application at run time.
Your code must have the flexibility to instantiate and work with any of the subclasses.
Solution
Design a factory method that will, based on its parameters, create and return an object of the correct subclass type.
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

5. Review: Factory Method Example
ComputerPlayer
Throw
Calculator
SmartThrow
RandomThrow
GeniusThrow
ThrowCalculator calc =
ThrowCalculator.makeCalculator(type, ...);
public abstract class ThrowCalculator {
public static ThrowCalculator makeCalculator(int type, ...)
switch (type) {
case RANDOM: return new RandomThrow(...); break;
case SMART: return new SmartThrow(...); break;
case GENIUS: return new GeniusThrow(...); break; }
public abstract Throw calculateThrow(...); // abstract method
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

6. Review: Coding to the Interface
ComputerPlayer
Throw
Calculator
SmartThrow
RandomThrow
GeniusThrow
ThrowCalculator calc = ThrowCalculator.makeCalculator(type, ...);
Throw t = calc.calculateThrow(...);
Variable calc has the interface type ThrowCalculator.
It refers to an object that can be a RandomThrow, a SmartThrow, or a GeniusThrow.
An object of one of those types is returned by the factory.
Variable t = calc.calculateThrow(...) doesn’t care which type of object calc refers to.
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

7. The Strategy Design Pattern
Context
There are different algorithms (“strategies”) to solve a particular problem.
Description
The algorithms all have similar public interfaces, but each solves the problem in a different way.
Solution
Create a strategy interface that is an abstraction of the algorithm.
Declare the public interface shared by the algorithms.
Code each strategy in a class that implements the strategy interface.
At run time, select one of the strategies and call its public interface methods. _
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

8. The Strategy Design Pattern
We’ve already seen examples of this pattern:
Calendar
Gregorian
Lunar
ComputerPlayer
Throw
Calculator
SmartThrow
RandomThrow
GeniusThrow
Recall the Comparator interface used by the Collections class to sort an array list of objects.
How can you apply the strategy design pattern?
You can have several classes that implement the Comparator interface all with different compare() methods.
Compare by weight, height, etc.
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

9. A Powerful Technique for Flexibility
To achieve maximum code flexibility, combine
The strategy design pattern
The factory method design pattern
with dynamic class loading
Coding to the interface
The strategy design pattern tells us how to handle multiple algorithms to solve a problem.
The factory method design pattern tells us how to instantiate an algorithm at run time.
Coding to the interface ensures we don’t hard-code to any one algorithm.
Demo
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak

10. NetBeans Swing Tutorials
Introduction to GUI Building
Designing a Swing GUI in NetBeans IDE
NetBeans Swing design demo
SJSU Dept. of Computer Science
Fall 2013: October 8
CS 151: Object-Oriented Design © R. Mak