Drawing, Blinking, and Interfaces

1. Drawing, Blinking, and Interfaces

Title

Think Java 2e · Chapter 17 · Advanced Topics

Sections 17.5-17.7 · pp. 283-290

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 17 (Advanced Topics), Sections 17.5-17.7, pp. 283-290. Everything on these slides can be checked against those pages.

1. Build a canvas that holds a list of drawable objects and paints them all.

2. Define polymorphism and identify a polymorphic method and a polymorphic data structure.

3. Add per-object animation with a step method overridden in subclasses.

4. Explain what super.draw(g) does when the immediate superclass has no draw method.

5. Distinguish an interface from an abstract class.

6. Write a class that extends one class and implements an interface.

• 17.5 — An Initial Drawing
• 17.6 — Blinking Polygons
• 17.7 — Interfaces

3. Retrieve before you read

Warm-up

Three facts, all about to become the chapter's argument.

4. One list, many kinds of thing

Concept

A Drawing holds objects and draws them. The whole lesson is about widening what objects is allowed to mean.

• 17.5 — the Drawing class, and polymorphism
• 17.6 — blinking polygons: per-object animation
• 17.7 — interfaces, and why a superclass would not do

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 17 (Advanced Topics), Sections 17.5-17.7, pp. 283-290 — Section 17.5 opens on printed page 283.

5. The Drawing class

Section

Section 17.5

6. A canvas with a list

Concept

Now that we have DrawablePolygon and RegularPolygon, let's take them for a test drive. We'll need a Canvas for drawing them, so we define a new class, Drawing, that extends Canvas.

public class Drawing extends Canvas {
    private ArrayList<DrawablePolygon> list;

    public Drawing(int width, int height) {
        setSize(width, height);
        setBackground(Color.WHITE);
        list = new ArrayList<DrawablePolygon>();
    }

    public void add(DrawablePolygon dp) {
        list.add(dp);
    }

    public void paint(Graphics g) {
        for (DrawablePolygon dp : list) {
            dp.draw(g);
        }
    }
}

The Drawing class has an ArrayList of DrawablePolygon objects. When we create a Drawing object, the list is initially empty. This is Lesson 15a's GridCanvas with a list instead of a grid — the same specialization of the same library class, for a different shape of data.

7. paint, one more time

Notation

The third paint override in three chapters, and by now the pattern should read at a glance.

Delegating drawing to the objects is what makes the container reusable. Drawing would work unchanged if polygons were replaced by anything else that could draw itself — which is the observation Section 17.7 acts on.

8. Three polygons on a canvas

Worked example

Here is an example that creates three RegularPolygon objects and draws them.

public static void main(String[] args) {
    // create some regular polygons
    DrawablePolygon p1 = new RegularPolygon(3, 50, Color.GREEN);
    DrawablePolygon p2 = new RegularPolygon(6, 50, Color.ORANGE);
    DrawablePolygon p3 = new RegularPolygon(360, 50, Color.BLUE);

    // move them out of the corner
    p1.translate(100, 80);
    p2.translate(250, 120);
    p3.translate(400, 160);

    // create drawing, add polygons
    Drawing drawing = new Drawing(500, 250);
    drawing.add(p1);
    drawing.add(p2);
    drawing.add(p3);
}

9. Is this assignment legal?

Prediction

The variable is the superclass; the object is the subclass.

DrawablePolygon p1 = new RegularPolygon(3, 50, Color.GREEN);

10. Polymorphism

Concept

When we create the RegularPolygon objects, we assign them to DrawablePolygon variables. It might not be obvious why that's legal.

DrawablePolygon p1 = new RegularPolygon(3, 50, Color.GREEN);

polymorphism — A language feature that allows objects to be assigned to variables of related types.

RegularPolygon extends DrawablePolygon, so every RegularPolygon object is also a DrawablePolygon. The parameter of Drawing.add has to be a DrawablePolygon, but it can be any type of DrawablePolygon. Polymorphism is a fancy word that means having many forms — and it is Lesson 14a's substitution rule, finally named.

11. Calling a subclass method through a superclass variable

Trap

DrawablePolygon p = new RegularPolygon(6, 50, Color.BLUE);

p.draw(g);           // fine - DrawablePolygon has draw
p.getNumSides();     // compile error, even though the object has it

// if you only need the shared behaviour:
DrawablePolygon p = new RegularPolygon(6, 50, Color.BLUE);

// if you need RegularPolygon's own methods:
RegularPolygon rp = new RegularPolygon(6, 50, Color.BLUE);

12. Which are polymorphic?

Definition probe

A method or a structure can be.

13. Paint every polygon

Fill the middle

Each object draws itself.

14. Why does the compiler check the declared type?

Socratic

The object really does have the method.

15. Animating the drawing

Section

Section 17.6

16. A step method, all the way down

Concept

At this point, we have a simple program that draws polygons; we can make it more fun by adding animation. Chapter 15 introduced the idea of simulating time steps.

while (true) {
    drawing.step();
    try {
        Thread.sleep(1000 / 30);
    } catch (InterruptedException e) {
        // do nothing
    }
}

Each time through the loop, we call step to update the Drawing. Then we sleep with a delay calculated to update about 30 times per second. The same loop as Lesson 15b and Lesson 16 — the third appearance of update, repaint, sleep.

17. step cascades down the list

Picture it

One call at the top becomes one call per object, and then a repaint.

It invokes step on each DrawablePolygon in the list and then repaints (clears and redraws) the canvas. Drawing knows when to update and nothing about what updating means — which is why the same container can animate a blinking polygon and a moving sprite.

18. A do-nothing step to override

Worked example

In order for this code to compile, we need DrawablePolygon to provide a step method. Here's a version that doesn't do anything; we'll override it in subclasses.

// in DrawablePolygon:
public void step() {
    // do nothing
}

// in Drawing:
public void step() {
    for (DrawablePolygon dp : list) {
        dp.step();
    }
    repaint();
}

19. Which draw does super.draw call?

Prediction

BlinkingPolygon extends RegularPolygon, which has no draw.

public class BlinkingPolygon extends RegularPolygon {
    public void draw(Graphics g) {
        if (visible) {
            super.draw(g);
        }
    }
}

20. The blinking polygon

Concept

Now let's design a new type of polygon that blinks. Two new attributes and two overridden methods.

public class BlinkingPolygon extends RegularPolygon {
    protected boolean visible;
    protected int count;

    public BlinkingPolygon(int nsides, int radius, Color c) {
        super(nsides, radius, c);
        visible = true;
        count = 0;
    }

    public void draw(Graphics g) {
        if (visible) {
            super.draw(g);
        }
    }

    public void step() {
        count++;
        if (count == 10) {
            visible = !visible;
            count = 0;
        }
    }
}

The step method increments count. Every 10 time steps, it toggles visible and resets count to 0. At 30 frames per second that is a blink about three times a second — and visible = !visible is Lesson 5b's logical negation doing the toggling.

21. Forgetting super.draw and losing the drawing

Trap

public void draw(Graphics g) {
    if (visible) {
        // now what? re-implement fillPolygon here?
    }
}

public void draw(Graphics g) {
    if (visible) {
        super.draw(g);
    }
}

22. How often does it blink?

Prediction

30 frames per second, toggling every 10 steps.

public void step() {
    count++;
    if (count == 10) {
        visible = !visible;
        count = 0;
    }
}

23. Toggle the visibility

Fill the middle

Count up, then flip.

24. Why is step empty in DrawablePolygon?

Explain it to yourself

Lesson 16 made a similar method abstract.

25. The problem with a superclass

Section

Section 17.7

26. Drawing does exactly three things

Concept

You might be getting tired of polygons at this point. Can't we draw anything else? Of course we can, but Drawing is currently based on DrawablePolygon. To draw other types of objects, we have to generalize the code.

// The Drawing class does essentially three things:
//   1. it maintains a LIST of objects
//   2. it invokes the DRAW method on each object
//   3. it invokes the STEP method on each object

Two methods. Everything else about DrawablePolygon is irrelevant to Drawing — which means requiring the elements to be DrawablePolygons is asking for far more than is needed.

27. The obvious fix, and why it fails

Notation

So here's one way we could make the code more general — and the book proposes it before rejecting it.

Java provides another mechanism for inheritance that solves these problems. The constraint is real and the workaround is a language feature, which is a good sign the constraint was deliberate.

28. Actor as an interface

Worked example

We can define Actor as an interface instead of a class.

public interface Actor {
    void draw(Graphics g);
    void step();
}

29. Why can't Actor be a superclass?

Prediction

DrawablePolygon would need to extend it.

public class DrawablePolygon extends Polygon { ... }
// and now it should also extend Actor?

30. Interface against abstract class

Concept

They overlap enough to be confused and differ in exactly the ways that matter here.

Automaton had to be an abstract class because it carried run and mainloop — real code the subclasses inherited. Actor can be an interface because it carries nothing but two signatures. The choice follows from whether there is shared implementation to give away.

31. Trying to extend two classes

Trap

public class DrawablePolygon extends Polygon, Actor {
    // compile error
}

public class DrawablePolygon extends Polygon implements Actor {
    // rest of the class omitted
}

32. Interface or abstract class?

Definition probe

The deciding question is whether there is shared code.

33. Declare and implement

Fill the middle

Two methods, no bodies.

34. Is an interface always better?

Counterexample

It removes the one-superclass limit.

35. Implementing an interface

Section

Section 17.7

36. One object, several types

Concept

In terms of inheritance, DrawablePolygon is both a Polygon and an Actor. So the following assignments are legal.

Polygon p1 = new DrawablePolygon();
Actor   a1 = new DrawablePolygon();

Polygon p2 = new RegularPolygon(5, 50, Color.YELLOW);
Actor   a2 = new RegularPolygon(5, 50, Color.YELLOW);

And the same is true for subclasses of DrawablePolygon. A RegularPolygon inherits both the extends and the implements — so it is an Actor without saying so, which is what lets Drawing hold one.

37. The type graph

Picture it

One chain of classes, and an interface cutting across it.

Classes may extend only one superclass, but they may implement as many interfaces as needed. Java library classes often implement multiple interfaces. That is why the class hierarchy is a tree while the type graph is not.

38. What changes in Drawing

Worked example

Generalising the container is now a search and replace.

// before
private ArrayList<DrawablePolygon> list;
public void add(DrawablePolygon dp) { list.add(dp); }

// after
private ArrayList<Actor> list;
public void add(Actor a) { list.add(a); }

39. Is a RegularPolygon an Actor?

Prediction

Only DrawablePolygon says implements.

public class DrawablePolygon extends Polygon implements Actor { }
public class RegularPolygon extends DrawablePolygon { }

Actor a = new RegularPolygon(5, 50, Color.YELLOW);

40. Interfaces are polymorphism too

Concept

a1 and a2 are the same type of variable, but they refer to objects with different types. And similarly with p1 and p2.

Actor a1 = new DrawablePolygon();
Actor a2 = new RegularPolygon(5, 50, Color.YELLOW);

// and in Lesson 17c:
Actor a3 = new Sprite("face-smile.png", 25, 150);

Sprite and RegularPolygon have nothing in common — one wraps an image file, the other computes vertices with trigonometry. Yet both can sit in the same list, because an interface describes what a thing can do rather than what it is descended from.

41. Implementing an interface without all its methods

Trap

public class Sprite implements Actor {
    public void draw(Graphics g) { ... }
    // no step method
}

// error: Sprite is not abstract and does not override
//        abstract method step() in Actor

public class Sprite implements Actor {
    public void draw(Graphics g) { ... }
    public void step() { ... }
}

// and where a method genuinely has nothing to do:
public void keyTyped(KeyEvent e) {
    // do nothing
}

42. How many can you have?

Definition probe

The rules differ for the two mechanisms.

43. Match the keyword to what follows it

Matching

Four declarations from this lesson.

44. Why does Java forbid multiple inheritance of classes?

Real world

Interfaces can be inherited freely; classes cannot.

45. Designing to a capability

Section

Sections 17.5-17.7 together

46. The whole lesson in one substitution

Concept

Drawing began holding polygons and ends holding anything that can draw and step. Nothing inside it changed except one type name.

// before: a container of a particular class
private ArrayList<DrawablePolygon> list;

// after: a container of a capability
private ArrayList<Actor> list;

The generalization was cheap because the coupling was already loose. Drawing never called a polygon method — which was not an accident but the consequence of letting each object draw itself.

47. Three ways of saying *these things are alike*

Notation

Chapters 14, 16 and 17 each added a mechanism, and they are not interchangeable.

Choose by what you have to give away. Shared code means a class; a bare capability means an interface; both means an abstract class.

48. Reading a declaration with both

Worked example

public class DrawablePolygon extends Polygon implements Actor says three things at once.

public class DrawablePolygon extends Polygon implements Actor {
    // rest of the class omitted
}

49. Which mechanism?

Definition probe

Superclass, abstract class, or interface.

50. What Lesson 17c does with this

Concept

The interface was introduced to make room for something that is not a polygon at all.

Now that our Drawing is based on Actor instead of DrawablePolygon, we can draw other types of graphics. Sprite implements two interfaces, which is where the as many as needed rule stops being theoretical.

51. Putting a method in the interface that only some implementers need

Trap

public interface Actor {
    void draw(Graphics g);
    void step();
    void translate(int dx, int dy);   // polygons have this
    Color getColor();                  // sprites do not
}

public interface Actor {
    void draw(Graphics g);
    void step();
}

52. How many types does a BlinkingPolygon have?

Prediction

Count the whole chain, plus the interface.

class BlinkingPolygon extends RegularPolygon
class RegularPolygon extends DrawablePolygon
class DrawablePolygon extends Polygon implements Actor

53. Generalise the container

Fill the middle

Depend on the capability, not the class.

54. Why is Actor the right size?

Explain it to yourself

Two methods, no more.

55. Three ways to share a type

Comparison

Fill the blanks.

The fourth row is the one that decided this chapter. DrawablePolygon had already spent its one extends on Polygon, so only an interface could add the Actor type on top.

56. The pattern to carry away

Pattern

Depend on a capability, not a class — then anything that has the capability fits.

// 1. name the capability the consumer needs
public interface Actor {
    void draw(Graphics g);
    void step();
}

// 2. the consumer holds the interface, not a concrete class
public class Drawing extends Canvas {
    private ArrayList<Actor> list;
    public void add(Actor a) { list.add(a); }
    public void paint(Graphics g) {
        for (Actor a : list) { a.draw(g); }
    }
}

// 3. anything at all can implement it
public class DrawablePolygon extends Polygon implements Actor { }
public class Sprite implements Actor, KeyListener { }

• Polymorphism is assigning an object to a variable of a related type.
• A polymorphic method takes a parameter that can be one of many types.
• An interface has declarations only; an abstract class can implement some methods.
• Override to add a condition, then call super to keep the original behaviour.
• An empty method body is right when doing nothing is correct; abstract is right when it is not.

57. Check: super through a gap

Check

Work it out before you click.

class DrawablePolygon { public void draw(Graphics g) { ... } }
class RegularPolygon extends DrawablePolygon { /* no draw */ }
class BlinkingPolygon extends RegularPolygon {
    public void draw(Graphics g) {
        if (visible) { super.draw(g); }
    }
}

58. Check: interface against abstract class

Check

Work it out before you click.

public interface Actor {
    void draw(Graphics g);
    void step();
}

59. Check: polymorphism

Check

Work it out before you click.

DrawablePolygon p = new RegularPolygon(6, 50, Color.BLUE);
drawing.add(p);
// public void add(DrawablePolygon dp)

60. Interfaces are how libraries stay open

Real world

Drawing can display objects whose classes did not exist when Drawing was written.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Three sections that build a container, animate it, and then widen what it can contain.

• Drawing extends Canvas and holds a list, painting each object by asking it to draw itself.
• Polymorphism is assigning an object to a variable of a related type.
• Drawing.add is a polymorphic method, and its ArrayList a polymorphic data structure.
• step is empty in DrawablePolygon and overridden by subclasses that animate.
• super.draw(g) searches upward past RegularPolygon to DrawablePolygon.
• A superclass would not work for Actor — DrawablePolygon already extends Polygon.
• An interface declares methods without implementing any, and has no attributes.
• extends once, implements as many as needed, and a subclass inherits its parent's interfaces.