Refactoring, Abstract Classes, and UML

1. Refactoring, Abstract Classes, and UML

Title

Think Java 2e · Chapter 16 · Reusing Classes

Sections 16.1-16.4 · pp. 267-274

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 16 (Reusing Classes), Sections 16.1-16.4, pp. 267-274. Everything on these slides can be checked against those pages.

1. Implement Langton's Ant using the Cell and GridCanvas classes unchanged.

2. Use the remainder operator to make a direction wrap around, and explain why turning left adds 3.

3. Define refactoring and recognise when repeated code calls for it.

4. Extract a superclass containing the code two classes have in common.

5. Explain what protected, abstract class and abstract method each mean.

6. Read a UML diagram that shows inheritance, composition, use, and an abstract class.

• 16.1 — Langton's Ant
• 16.2 — Refactoring
• 16.3 — Abstract Classes
• 16.4 — UML Diagram

3. Retrieve before you read

Warm-up

Four things, all of which this chapter reuses without ceremony.

4. A second game, and what it exposes

Concept

One of the most interesting zero-player games is Langton's Ant, which models an ant that walks around a grid. The ant follows only two simple rules.

• 16.1 — implementing Langton's Ant
• 16.2 — refactoring: extracting an Automaton superclass
• 16.3 — abstract classes, abstract methods, and protected
• 16.4 — the finished UML diagram

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 16 (Reusing Classes), Sections 16.1-16.4, pp. 267-274 — Chapter 16 opens on printed page 267.

5. Langton's Ant

Section

Section 16.1

6. Two rules, and unpredictable behaviour

Concept

Because the rules are simple, you might expect the ant to do something simple, like make a square or repeat a simple pattern.

// 1. If the ant is on a WHITE cell, it turns to the RIGHT,
//    makes the cell black, and moves forward.
//
// 2. If the ant is on a BLACK cell, it turns to the LEFT,
//    makes the cell white, and moves forward.

But starting on a grid with all white cells, the ant makes more than 10,000 steps in a seemingly random pattern before it settles into a repeating loop of 104 steps. Two rules, and nobody can predict that from reading them — the same lesson as the Game of Life, from a completely different mechanism.

7. Where the ant starts

Picture it

One ant, at the middle of a white grid, facing north. Everything else follows.

There is no randomness anywhere in this program. The same starting state always produces the same 10,000 steps — which makes seemingly random exactly the right phrase.

8. The Langton class

Worked example

We begin by defining a Langton class that has a grid and information about the ant.

public class Langton {
    private GridCanvas grid;
    private int xpos;
    private int ypos;
    private int head;   // 0=North, 1=East, 2=South, 3=West

    public Langton(int rows, int cols) {
        grid = new GridCanvas(rows, cols, 10);
        xpos = rows / 2;
        ypos = cols / 2;
        head = 0;
    }
}

9. What does head = 0 mean?

Prediction

Four values, one per direction.

private int head;   // 0=North, 1=East, 2=South, 3=West

10. Encoding a direction

Concept

head is Lesson 12a's encoding argument in a fourth setting: four things represented by four integers, so that arithmetic can act on them.

The order is deliberate: clockwise. North, east, south, west — so turn right is add one, which is the arithmetic the next section depends on. Choosing 0 = north and going clockwise is a design decision that makes one line of code possible.

11. Confusing xpos and ypos with rows and columns

Trap

xpos = rows / 2;                        // xpos from ROWS
ypos = cols / 2;                        // ypos from COLS
Cell cell = grid.getCell(xpos, ypos);   // getCell(r, c)

// grid.getCell(r, c) takes ROW first (Lesson 15a)
// so in this class, xpos is the row index and ypos the column

// clearer, if you were writing it fresh:
private int row;
private int col;

12. Which class is responsible?

Definition probe

Cell and GridCanvas were not modified.

13. The Langton constructor

Fill the middle

Start in the middle, facing north.

14. Why does simple produce complicated?

Socratic

Two rules, ten thousand unpredictable steps.

15. Turning with the remainder operator

Section

Section 16.1

16. flipCell does all three parts of a rule

Concept

The flipCell method gets the Cell at the ant's location, figures out which way to turn, and changes the state of the cell.

private void flipCell() {
    Cell cell = grid.getCell(xpos, ypos);
    if (cell.isOff()) {
        head = (head + 1) % 4;    // turn right
        cell.turnOn();
    } else {
        head = (head + 3) % 4;    // turn left
        cell.turnOff();
    }
}

Both rules have the same three parts — turn, flip the cell, move forward — so flipCell does the first two and moveAnt does the third. The if splits on the cell's colour exactly as the rules do.

17. Why turning left adds three

Notation

The obvious way to turn left is to subtract one. Java makes that a bug.

(x + n) % k is the standard way to step around a cycle, and keeping the addend positive is the standard way to avoid Java's negative remainder. Worth remembering as one idiom.

18. Moving forward

Worked example

The moveAnt method moves the ant forward one square, using head to determine which way is forward.

private void moveAnt() {
    if (head == 0) {
        ypos -= 1;
    } else if (head == 1) {
        xpos += 1;
    } else if (head == 2) {
        ypos += 1;
    } else {
        xpos -= 1;
    }
}

19. Turning right from west

Prediction

head is 3; the ant is on a white cell.

head = (head + 1) % 4;

20. update, and what it does not do

Concept

Langton's update is two lines, and notably shorter than Conway's.

public void update() {
    flipCell();
    moveAnt();
}

Langton's Ant needs no two-pass update because only the cell under the ant changes, and nothing reads a neighbour. Lesson 15b's simultaneity problem simply does not arise — which is a useful reminder that the two-pass structure was solving a specific problem, not a general one.

21. Subtracting one to turn left

Trap

head = (head - 1) % 4;    // turn left - WRONG

// with head == 0:
//   (0 - 1) % 4  ->  -1 % 4  ->  -1 in Java

head = (head + 3) % 4;    // turn left

22. What is -1 % 4 in Java?

Prediction

The sign follows the left operand.

System.out.println(-1 % 4);

23. Turn in both directions

Fill the middle

Right adds one; left adds three.

24. What if head went out of range?

Edge cases

moveAnt ends with a bare else.

25. Refactoring

Section

Section 16.2

26. Two copies of the same main

Concept

And that's everything! Langton's Ant works, Cell and GridCanvas were not touched — however, we now have two copies of main and mainloop, one in Conway, and one in Langton.

public static void main(String[] args) {
    String title = "Langton's Ant";
    Langton game = new Langton(61, 61);
    JFrame frame = new JFrame(title);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setResizable(false);
    frame.add(game.grid);
    frame.pack();
    frame.setVisible(true);
    game.mainloop();
}

Most of this code is the same as the main we used to create and run Conway, in Section 15.6. Two lines differ and seven do not — which is the shape that Chapter 14 taught you to recognise.

27. Refactoring, defined

Notation

The chapter names the technique it has just used twice.

Refactor: to restructure or reorganize existing source code without changing its behavior. Six words of the definition are without changing its behavior, and they are the important ones.

28. Extracting Automaton

Worked example

First, we define a superclass named Automaton, in which we will put the code that Conway and Langton have in common.

public class Automaton {
    private GridCanvas grid;

    public void run(String title, int rate) {
        JFrame frame = new JFrame(title);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.add(this.grid);
        frame.pack();
        frame.setVisible(true);
        this.mainloop(rate);
    }
}

29. What is the delay when rate is 4?

Prediction

The rate is frames per second.

Thread.sleep(1000 / rate);

30. mainloop, with a frame rate

Concept

mainloop contains the code you first saw in Section 15.7, with the hard-coded pause replaced by a computed one.

private void mainloop(int rate) {
    while (true) {
        // update the drawing
        this.update();
        grid.repaint();

        // delay the simulation
        try {
            Thread.sleep(1000 / rate);
        } catch (InterruptedException e) {
            // do nothing
        }
    }
}

For example, if rate is 2, we should draw two frames per second, so the delay is a half second, or 500 milliseconds. The parameter is the rate rather than the delay, which is the more natural thing for a caller to specify — run(title, 2) says two frames a second without any arithmetic at the call site.

31. Refactoring and changing behaviour at once

Trap

// while moving main into Automaton, also:
//   - change the frame rate from 2 to 10
//   - add a border to the window
//   - fix that thing in update

// then the animation looks wrong. Which change caused it?

// step 1: move the code, change nothing else
//         run both simulations - identical behaviour?
//
// step 2: NOW change the frame rate

32. Shared or specific?

Definition probe

What belongs in Automaton and what does not.

33. The shared loop

Fill the middle

Update, redraw, pause.

34. Why refactor when nothing is broken?

Explain it to yourself

Both programs work.

35. Abstract classes

Section

Section 16.3

36. Three problems with the design so far

Concept

If we were not planning to implement any other zero-person games, we could leave well enough alone. But there are a few problems with the current design.

All three are the same kind of problem: the class does not say what it means. It means grid is for subclasses, do not instantiate me, and you must supply update — and nothing in the code says any of it.

37. Three keywords, three fixes

Notation

Java provides language features to solve these problems.

Any class that extends Automaton must provide an implementation of update; the declaration here allows the compiler to check. That last clause is the whole value: the design rule stops being a convention.

38. Automaton as an abstract class

Worked example

Here's what Automaton looks like as an abstract class.

public abstract class Automaton {
    protected GridCanvas grid;

    public abstract void update();

    private void mainloop(int rate) {
        // this method invokes update
    }

    public void run(String title, int rate) {
        // this method invokes mainloop
    }
}

39. What does new Automaton() do?

Prediction

Automaton is declared abstract.

public abstract class Automaton { ... }

Automaton a = new Automaton();

40. Conway as a subclass

Concept

Here's what Conway looks like as a subclass of Automaton. Everything shared has gone.

public class Conway extends Automaton {
    // same methods as before, except mainloop is removed

    public static void main(String[] args) {
        String title = "Conway's Game of Life";
        Conway game = new Conway();
        game.run(title, 2);
    }
}

Conway extends Automaton, so it inherits the protected instance variable grid and the methods mainloop and run. But because Automaton is abstract, Conway has to provide update and a constructor (which it has already). Twelve lines of main become three.

41. Forgetting to implement an abstract method

Trap

public class Brian extends Automaton {
    public Brian() { grid = new GridCanvas(50, 50, 10); }
    // no update method
}

// error: Brian is not abstract and does not override
//        abstract method update() in Automaton

public class Brian extends Automaton {
    public Brian() { grid = new GridCanvas(50, 50, 10); }

    public void update() {
        // Brian's Brain rules go here
    }
}

42. Which access level?

Definition probe

Three levels, three audiences.

43. Match the term to its definition

Matching

Chapter 16's vocabulary.

44. Could Automaton just have an empty update?

Counterexample

A do-nothing method body would compile.

45. The finished design

Section

Section 16.4

46. Five classes and four relationships

Concept

At the beginning of the chapter, we had three classes: Cell, GridCanvas, and Conway. We then developed Langton, which had almost the same main and mainloop methods as Conway. So we refactored the code and created Automaton.

The diagram shows three examples of inheritance and two examples of composition. It also shows a third kind of arrow: Automaton uses JFrame, GridCanvas uses Graphics, and Cell uses Graphics and Color — a class that appears only inside a method, not as an attribute.

47. The whole design

Picture it

Figure 16.1 summarizes the final design.

Automaton is in italics to indicate that it is an abstract class. As it happens, Graphics is an abstract class, too — the convention you have been using all along was itself abstract.

48. Abstract against concrete

Worked example

Conway and Langton are concrete classes, because they provide an implementation for all of their methods.

// abstract - declares update, does not implement it
public abstract class Automaton {
    public abstract void update();
}

// concrete - implements every method it has
public class Conway extends Automaton {
    public void update() { ... }
}

49. Which relationship?

Definition probe

Three kinds of arrow in Figure 16.1.

50. Why UML earns its keep here

Concept

One of the challenges of object-oriented programming is keeping track of a large number of classes and the relationships between them. UML class diagrams can help.

Six classes is already more than fits comfortably in your head, and this is a small program. The diagram is the only representation that shows all the relationships at once — which is why Lesson 14b called it a shared notation worth learning.

51. Making grid public to fix the access problem

Trap

public class Automaton {
    public GridCanvas grid;      // now every class can reach it
}

// somewhere unrelated:
someOtherClass.game.grid = null;

public abstract class Automaton {
    protected GridCanvas grid;
}

52. What must a subclass of Automaton provide?

Prediction

Automaton declares update abstract.

public abstract class Automaton {
    protected GridCanvas grid;
    public abstract void update();
    public void run(String title, int rate) { ... }
}

53. Declare the abstract class

Fill the middle

A shared attribute and a required method.

54. Where else do abstract classes appear?

Real world

As it happens, Graphics is an abstract class, too.

55. The three access levels, and the two class kinds

Comparison

Fill the blanks.

protected is the row that changes. It is the only level that distinguishes my subclasses from everyone else — which is precisely the distinction a shared superclass attribute needs.

56. The pattern to carry away

Pattern

Extract a superclass, then make it abstract so the compiler enforces what it means.

// 1. two classes with duplicated code
public class Conway  { /* main, mainloop, update */ }
public class Langton { /* main, mainloop, update */ }

// 2. move what is shared into a superclass;
//    what differed becomes a parameter
public class Automaton {
    private GridCanvas grid;
    public void run(String title, int rate) { ... }
}

// 3. say what you mean, and let the compiler check it
public abstract class Automaton {
    protected GridCanvas grid;      // subclasses only
    public abstract void update();  // subclasses MUST supply
}

• Repeated code is the signal to refactor, whether or not anything is broken.
• Refactor first, change behaviour second — never both in one edit.
• What is the same becomes the method; what differs becomes a parameter.
• An abstract class carries implementation as well as obligation.
• (x + k − 1) % k steps backward around a cycle without going negative.

57. Check: turning left

Check

Work it out before you click.

head = (head + 3) % 4;    // turn left
// why not (head - 1) % 4 ?

58. Check: abstract

Check

Work it out before you click.

public abstract class Automaton {
    public abstract void update();
}

public class Brian extends Automaton {
    public Brian() { ... }
    // no update method
}

59. Check: protected

Check

Work it out before you click.

public abstract class Automaton {
    protected GridCanvas grid;
}

60. Refactoring is a named practice

Real world

This process of reorganizing existing code, without changing its behavior, is known as refactoring.

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

One chapter, one argument: write a second simulation, notice the duplication, remove it, then say what you mean.

• Cell and GridCanvas were reused unchanged — the test of Chapter 15's design, and it passed.
• Langton's Ant has two rules and takes 10,000 unpredictable steps before settling into a 104-step loop.
• head encodes four directions clockwise, so turning right is (head + 1) % 4.
• Turning left adds 3, because -1 % 4 is -1 in Java.
• Refactoring is restructuring without changing behaviour — which is what makes it checkable.
• Automaton holds what Conway and Langton share; title and rate are the parameters for what differed.
• protected means subclasses but not other classes — the level neither private nor public provides.
• An abstract class cannot be instantiated; an abstract method must be implemented by every concrete subclass.