1. Java Interface, Abstract Class, and Event-Driven Animations
Week 8
IAT-265, Fall 2009
Instructor: Eric Yang SIAT SFU Surrey

2. About Midterm & Final Exam
Reduce the Midterm from 15% to 10% of your final grade
May use your final exam to override it if it turns out to make you better off
Add an assignment to account for 5% of your final grade
Must be done individually and students will be asked how & why each question is done in person
Final exam, as specified in Syllabus, must be attained an passing grade (50%) in order to obtain a clear pass (C- or better) - strictly enforced!!

3. Today’s topics The concept of Interface in Java
Implementing an Interface
Benefits of Interfaces
Abstract Class
Comparison of Interfaces and Abstract Classes
Timer-Based Animation

4. The concept of Interface in Java
A group of declared methods with no method bodies (i.e. { … }) associated with them, and classes can promise to implement it
Example:
public interface Mover {
boolean changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
void move(); }
class MountainBike extends Bicycle implements Mover {
// You must implement here ALL the methods defined in Mover
The methods of an interface are also called abstract methods because it only declares signatures without implementations

5. Why Interface? Classes let us group similar objects together
Inheritance lets us group similar classes together  major goal is code reuse
Sometimes we’d like to group together objects that are related only because they all share some common behaviours
E.g. think about humans, birds, ants, space aliens, and robotics, what are the common behaviour among them?
Is it appropriate to give them a single superclass?

6. Interface: Group Objects with the Same Behaviours
Java’s interface specifies a set of responsibilities (in other words – a role)
If a class promise to implement an interface, it must implement every method declared in the interface
The interface provides an description of the capabilities it has
There is no code sharing involved with interface, as each class has to implement its own version of the methods declared
A class can implement many interfaces, separated by commas – a way to break single-parent inheritance mode and build multiple is-a relationships:
TalentedPerson extends Person implements Walker, Pilot, Friend, Musician { … }

7. Case study: An Interface for Shape Classes
Creating classes to represent rectangles, circles, and triangles and compute their area and a perimeter
But code sharing isn’t useful in this case because each shape computes its area and perimeter in a totally different way
It may seem as though there is an inheritance relationship here, because rectangle, circle, and triangle are all shapes

8. Define Interface Shape
A better solution would be to write an interface called Shape to represent the common functionality of all shapes: the ability to compute an area and a perimeter
// A general interface for all shape classes
public interface Shape {
public double getArea();
public double getPerimeter(); }
An interface cannot be instantiated. In our case, any code trying to create a new Shape() would not compile
It is, however, legal to create variables of type Shape that can refer to any object that implements the Shape interface

9. Implementing an Interface
We must do two things:
Declare that a class “implments” the interface
Implement each of the interface’s methods in the class
The general syntax for declaring that a class implements interfaces is the following:
public class <name> implements <interface name>, <interface name>, …, <interface name> {
. . . }

10. class Rectangle implements interface Shape
public class Rectangle implements Shape {
private double width;
private double height;
// Constructs a new rectangle with the given dimensions.
public Rectangle(double width, double height) {
this.width = width;
this.height = height; }
// Returns the area of this rectangle.
public double getArea() {
return width * height;
// Returns the perimeter of this rectangle.
public double getPerimeter() {
return 2.0 * (width + height);

11. class Circle implements interface Shape
public class Circle implements Shape {
private double radius;
// Constructs a new circle with the given radius.
public Circle(double radius) {
this.radius = radius; }
// Returns the area of this circle.
public double getArea() {
return Math.PI * radius * radius;
// Returns the perimeter of this circle.
public double getPerimeter() {
return 2.0 * Math.PI * radius;

12. class Triangle implements interface Shape
As per Heron’s formula, the area of a triangle with sides of length a, b, and c is related to a value s equal to half the triangle’s perimeter:
As per Heron’s formula, the area of a triangle with sides of length a, b, and c is related to a value s equal to half the triangle’s perimeter:
public class Triangle implements Shape {
private double a;
private double b;
private double c;
// Constructs a new Triangle given side lengths.
public Triangle(double a, double b, double c) {
this.a = a;
this.b = b;
this.c = c; }
// Returns this triangle's area using Heron's formula.
public double getArea() {
double s = (a + b + c) / 2.0;
return Math.sqrt(s * (s - a) * (s - b) * (s - c));
// Returns the perimeter of this triangle.
public double getPerimeter() {
return a + b + c;

13. Benefits of Interfaces
Classes that implements a common interface form a type hierarchy similar to those created by inheritance
The interface serves as a parent type for the classes that implement it
The major benefit of interfaces is that we can use them to achieve -polymorphism

14. Polymorphism – Its 2nd Meaning
Parent class or interface can be used as the declared type of its subclasses
E.g. if we have an interface Mover (with a method move() declared) that is implemented by classes AirPlane, Whale, and Bicycle, we can then write:
Mover mover = new AirPlane(); or
Mover mover = new Whale ();
Mover mover = new Bicycle ();
If we send the message
mover.move();
The variable will move according to its actual type: AirPlane: fly in the sky, Whale: swim, and Bicycle: roll

15. Polymorphism in Action
Allow us to do unified processing to objects of different types:
Create an array of Shape and then process using loops
Define a Shape as parameter to a method
Return a Shape from a method
public class ShapesMain {
public static void main(String[] args) {
Shape[] shapes = new Shape[3];
shapes[0] = new Rectangle(18, 18);
shapes[1] = new Triangle(30, 30, 30);
shapes[2] = new Circle(12);
for (int i = 0; i < shapes.length; i++) {
System.out.println("area=" + shapes[i].getArea() +
", perimeter=" + shapes[i].getPerimeter()); }

16. Abstract Class
First let’s look at an example, and then we talk about why we need a class type – Abstract Class in Java
Think about a class for all Animals, we can define a standard move method for them:
public abstract class Animal { …
public void move (Location location){
legs.moveForward(); }
However, different animal types move in very different ways: Monkeys, Swans, Snakes, Penguins, … 
Makes a single standard implementation for all impossible

17. Why Abstract Class?
When you want all the subclasses of a given class to define the same method, but there is no standard implementation, the solution is to define an abstract class that incorporates an abstract method

18. Syntax for Abstract Class
In Java, a class that contains an abstract method must itself be declared as an abstract class, like this:
public abstract class Animal { …
public abstract void move (Location location); }
An abstract method is one declared without an implementation (i.e. no method body { … })
Different from interface, abstract class’ abstract methods must use the abstract keyword

19. Annotations for Abstract Class
An abstract class is one declared abstract:
An abstract class doesn’t have to contain any abstract method
When a class contains an abstract method, it must be declared as abstract
Abstract class cannot be instantiated, but can be used as superclass
Like interface, it can serve as declared type for its subclasses’ objects  to realize polymorphism

20. Abstract Classes in AWT & Swing
Object
AWT
Component
Container
Layout manager classes are in the AWT
Class
Window
Abstract Class
Frame
Swing
JFrame
JComponent
AbstractButton
JPanel
JLabel
JMenuBar
JMenuItem
JButton
JTextComponent
JMenu
JTextArea
JTextField

21. Comparison of Interfaces and Abstract Classes

22. Timer-Based Animation
The basic idea behind animation:
Draw a graphical image over and over with slight changes from time to the next, so that it looks as though:
Moving
Changing size, angle, color, etc.
To make this work, Java provides a Timer object
javax.swing.Timer

23. How Java Timer works javax.swing.Timer works like a metronome:
Once we start it, it keeps on going until we stop it
While going, it provides a steady “ticking” that only the program can hear
On each tick, certain actions that we can specify are performed
To understand how this work, you need to know Java Event Model

24. The Java Event Model
Some source objects (timer, button, window, mouse, etc.) fire Events
Events: timer ticks; user presses a button or selects a menu item, opens a window, clicks a mouse, …
Any object interested in hearing about a particular event can register with the event source as a listener
When the event happens, Java notifies the listeners automatically
Each listener decides how it will respond with its event handler method(s)

25. The Java Event Model (2)

26. Event-Handling Code
Create a source (some object that generates an event, like a Timer or its subclass)
Create a middleman object called a listener that registers with the source
Create one or more responders - objects that will respond to the event

27. Example: 1. Define an Event Source: MoveTimer
/**
* MoveTimer.java
* A subclass of javax.swing.Timer that can be used for animation.
* It also serves as an example of the code for an "event source" object. */
public class MoveTimer extends Timer {
private Mover _mover; // peer object
public MoveTimer (int anInterval, Mover aMover) {
super(anInterval, null);
_mover = aMover;
this.addActionListener(new MoveListener(_mover)); }
This program is courtesy to K.E. Sanders et al. Object-Oriented Programming in Java. Pearson. 2006
Mover – an interface - is the object that responds to MoveTimer
Any instance of a class that implements the Mover can play this role
Mover – an interface - is the object that responds to MoveTimer
Any instance of a class that implements the Mover can play this role

28. Annotations for MoveTimer
Signature of Timer Constructor:
Timer(int delay, ActionListener listener)
Parameters:
delay – time interval between ticks (in milliseconds, 1 sec = 1000 milliseconds)
listener - an initial listener; can be null

29. 2. Create a listener that registers with the source
this.addActionListener(new MoveListener(_mover));
This statement create a MoveListener object, and pass Mover object to it, and register it as ActionListener with MoveTimer
public class MoveListener implements java.awt.event.ActionListener {
private Mover _mover;
public MoveListener (Mover aMover) {
super();
_mover = aMover; }
public void actionPerformed(java.awt.event.ActionEvent e){
_mover.move();
This program is courtesy to K.E. Sanders et al. Object-Oriented Programming in Java. Pearson. 2006

30. Annotations for ActionListener
Defined in java.awt.event package
public interface ActionListener extends EventListener{
actionPerformed(ActionEvent e);  }
The only thing the ActionListener interface requires is an actionPerformed method
actionPerformed method is executed on each beat of the MoveTimer
All it does here is to forward a message to the responder: _mover.move();

31. 3. Create responders - objects that will respond to the event
These objects must know how to move, i.e. with a move method implemented
A bouncing ball, a swimming fish, a moving ladybug
We enforce this feature by defining an interface – Mover, and requires these objects implement it
/* Mover.java
* Interface for objects that can move to a specified location.
* Must be implemented by objects that respond to a MoveTimer. */
public interface Mover {
public void move(); }
This program is courtesy to K.E. Sanders et al. Object-Oriented Programming in Java. Pearson. 2006

32. Using MoveTimer for animation: Make a Ball Bounce - BallApp**
* BallApp.java
* Displays a window with a red circle on a white background. */
public class BallApp extends javax.swing.JFrame {
public BallApp (String title) {
super(title);
this.setSize(600, 450);
this.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
this.add(new BallPanel());
this.setVisible(true); }
public static void main (String [ ] args) {
BallApp app = new BallApp ("BallApp");

33. Using MoveTimer for animation: Make a Ball Bounce - BallPanel
/* BallPanel.java
* Creates the panel to be placed inside the BallApp window. */
public class BallPanel extends javax.swing.JPanel implements Mover {
private final int INIT_X = 75; // attributes
private final int INIT_Y = 75;
private final int DIAMETER = 60;
private final int INTERVAL = 100;
private BouncingBall _ball; // components
private MoveTimer _timer;
public BallPanel () {
super();
_ball = new BouncingBall (java.awt.Color.red, this);
_timer = new MoveTimer(INTERVAL, this);
this.setBackground(java.awt.Color.white);
_ball.setLocation(INIT_X, INIT_Y);
_ball.setSize(DIAMETER, DIAMETER);
_timer.start(); }

34. Using MoveTimer for animation: Make a Ball Bounce – BallPanel (2)
public void move() {
_ball.move();
this.repaint(); }
public void paintComponent (java.awt.Graphics aBrush) {
super.paintComponent(aBrush);
java.awt.Graphics2D betterBrush = (java.awt.Graphics2D) aBrush;
_ball.fill(betterBrush);
The BallPanel class contains a MoveTimer. When instantiate MoveTimer we need to make two decisions:
How often it ticks (100 milliseconds in this case, framerate = 1000/100=10 fps)
what resopnder object should be register with it (better use BallPanel to coordinate potential more than one animated object

35. Using MoveTimer for animation: Make a Ball Bounce – BouncingBall
/**
* BouncingBall.java
* Extends ActiveEllipse, adding the ability to "bounce." */
public class BouncingBall extends ActiveEllipse implements Mover {
private int _changeX, _changeY; // attributes
private final int MOVE_LEN = 5;
private javax.swing.JPanel _panel; // peer object (and container)
private javax.swing.Timer _timer;
public BouncingBall (java.awt.Color aColor, javax.swing.JPanel aPanel){
super(aColor);
_changeX = MOVE_LEN;
_changeY = MOVE_LEN;
_panel = aPanel; }
//Methods so the BouncingBall knows how to move

36. Using MoveTimer: Make a Ball Bounce – BouncingBall (2)
public void move() {
int nextX = (int)this.getX() + _changeX;
int nextY = (int)this.getY() + _changeY;
this.setLocation(nextX, nextY); }
If we don’t consider the bouncing on boundary situation, just make the ball move, the implementation above is good enough
So for each ball’s move:
we get the ball’s current position along x by calling this.getX() and add the displacement _changeX;
we get the ball’s current position along y by calling this.getY() and add the displacement _changeY;
Reset its location using the new position value: this.setLocation(nextX, nextY);

37. As it is a bouncing ball …
We must consider the ball’s bouncing on the bounds of the window x
When ball hits panel’s Min Bound Y  reverse
When ball hits panel’s Max Bound X  reverse
When ball hits panel’s Min Bound X  reverse
When ball hits panel’s Max Bound Y  reverse y

38. BouncingBall (2) – Adding Conditional Check for Panel’s Bounds
public void move() {
int nextX = (int)this.getX() + _changeX;
int nextY = (int)this.getY() + _changeY;
if (nextX <= this.getMinBoundX()) {
_changeX *= -1;
nextX = this.getMinBoundX(); }
else if (nextX >= this.getMaxBoundX()) {
nextX = this.getMaxBoundX();
if (nextY <= this.getMinBoundY()) {
_changeY *= -1;
nextY = this.getMinBoundY();
else if (nextY > this.getMaxBoundY()){
nextY = this.getMaxBoundY();
this.setLocation(nextX, nextY);

39. Calculate the Ball’s Bounds …
As (nextX, nextY) are about the upper-left corner’s coordinates, so we must calcuate Ball’s bounds relative to it x
MinBoundY = panel’s y
MinBoundX = panel’s x
MaxBoundX = panel’s x + panel width – ball’s width
MaxBoundY = panel’s y + panel height – ball’s height y

40. BouncingBall (3) – Adding get methods for Min- & Max Bounds
public int getMinBoundX() {
return (int) _panel.getX(); }
public int getMinBoundY() {
return (int) _panel.getY();
public int getMaxBoundX() {
return (int) (_panel.getX() + _panel.getWidth()
- this.getWidth());
public int getMaxBoundY() {
return (int) (_panel.getY() + _panel.getHeight()
- this.getHeight());