Polygon Objects, Color, and More Constructors

1. Polygon Objects, Color, and More Constructors

Title

Think Java 2e · Chapter 17 · Advanced Topics

Sections 17.1-17.4 · pp. 277-283

2. What you will be able to do

Objectives

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

1. Distinguish generalization from specialization and give an example of each from earlier chapters.

2. Extend a library class you did not write, adding an attribute and a method.

3. Compute the vertices of a regular polygon from a number of sides and a radius.

4. Chain constructors with this(...) to give parameters default values.

5. Validate constructor arguments and throw an exception when they are invalid.

6. Explain why validation belongs in the most general constructor.

• 17.1 — Polygon Objects
• 17.2 — Adding Color
• 17.3 — Regular Polygons
• 17.4 — More Constructors

3. Retrieve before you read

Warm-up

Four things, one from each of the last four chapters.

4. Two directions of inheritance

Concept

You have used inheritance twice for opposite reasons, and Chapter 17 opens by giving each one a name.

• 17.1 — Polygon objects from java.awt
• 17.2 — adding colour by specialization
• 17.3 — regular polygons, and the trigonometry
• 17.4 — more constructors, chaining, and validation

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

5. Generalization and specialization

Section

Chapter opener

6. The same keyword, two purposes

Concept

When we first looked at inheritance in Chapter 14, our purpose was to avoid duplicating code. We noticed that decks of cards and hands of cards had common functionality, and we designed a CardCollection class to provide it. This technique is an example of generalization.

generalization — The process of extracting common code from two or more classes and moving it into a superclass.

specialization — Extending a class to add new attributes or methods, or to modify existing behavior.

By generalizing the code, we were able to reuse it in the Deck and Hand classes. Chapter 16 did both in one chapter: generalising Conway and Langton into Automaton, and specialising Canvas into GridCanvas.

7. Extending a class you did not write

Notation

The Chapter 15 case is worth re-reading now, because it makes a claim about library design.

Generalization is something you do to your own code; specialization is often something you do to someone else's. That asymmetry is why the chapter names them separately.

8. Recognising which one you are doing

Worked example

Every use of extends in this course is one or the other. Sorting them is a good test of whether the distinction has landed.

class Hand extends CardCollection     // Ch.14
class GridCanvas extends Canvas       // Ch.15
class Conway extends Automaton        // Ch.16
class DrawablePolygon extends Polygon // Ch.17

9. Generalization or specialization?

Definition probe

Ask which class existed first, and who wrote it.

10. Why the distinction is worth having

Concept

Two names for one keyword only earn their keep if they lead to different decisions — and they do.

The third row is the practical one. When you generalise, a bad fit is a design problem you can fix; when you specialise a library class, a bad fit is a constraint — which is exactly the situation Section 17.7 runs into with DrawablePolygon extends Polygon.

11. Extending a class that was not built for it

Trap

// suppose you want the ArrayList methods:
public class Inventory extends ArrayList<Item> {
    // now Inventory has add, remove, get, sort,
    // clear, subList, and 30 other methods
}

// Polygon IS the thing being drawn - the sentence holds,
// and Polygon's attributes are public by design
public class DrawablePolygon extends Polygon { ... }

// an inventory HAS items - composition, as in Lesson 13b
public class Inventory {
    private ArrayList<Item> items;
}

12. Which came first?

Prediction

The direction of the work, not the arrow.

public class Conway extends Automaton { ... }

13. Match the term to its definition

Matching

Chapter 17's vocabulary, part one.

14. Why can you extend a class you cannot see?

Explain it to yourself

You have never read Canvas's source.

15. Polygon objects

Section

Section 17.1

16. Many angles, from a list of points

Concept

The word polygon means many angles; the most basic polygons are triangles, rectangles, pentagons and so forth. Polygons are an important part of computer graphics because they are used to compose more complex images.

Polygon p = new Polygon();
p.addPoint(57, 110);
p.addPoint(100, 35);
p.addPoint(143, 110);

Java provides a Polygon class (in java.awt) that we can use to represent and draw polygons. A polygon is just an ordered list of vertices — the edges are implied, including the one from the last point back to the first.

17. Three attributes, two of them arrays

Picture it

Internally, Polygon objects have three attributes — and unusually, all three are public.

When a Polygon is created, npoints is 0 and the two arrays are initialized with length 4. So the array length and the number of points are two different things — which is exactly the distinction an ArrayList hides and this class does not.

18. How addPoint grows the arrays

Worked example

As points are added, npoints is incremented. If npoints exceeds the length of the arrays, larger arrays are created, and the previous values are copied over (similar to how ArrayList works).

public int npoints;      // total number of points
public int[] xpoints;    // array of X coordinates
public int[] ypoints;    // array of Y coordinates

19. What is npoints after three addPoint calls?

Prediction

It starts at zero.

Polygon p = new Polygon();
p.addPoint(57, 110);
p.addPoint(100, 35);
p.addPoint(143, 110);

20. Public attributes, unusually

Concept

Lesson 11a argued for private instance variables. Polygon's are public, and it is worth asking why the library made that choice.

Polygon is old and performance-sensitive — graphics code touches these arrays in tight loops, and going through getters was once a real cost. It also means RegularPolygon can fill xpoints and ypoints directly, which is what the next section does. A design decision you would not repeat, being relied upon.

21. Confusing npoints with the array length

Trap

Polygon p = new Polygon();
p.addPoint(57, 110);
p.addPoint(100, 35);
p.addPoint(143, 110);

for (int i = 0; i < p.xpoints.length; i++) {   // 4, not 3
    System.out.println(p.xpoints[i]);          // prints a stray 0
}

for (int i = 0; i < p.npoints; i++) {
    System.out.println(p.xpoints[i] + ", " + p.ypoints[i]);
}

22. Count or capacity?

Definition probe

Two numbers that are easy to confuse.

23. Build a triangle

Fill the middle

Three vertices, added in order.

24. Why parallel arrays rather than an array of points?

Socratic

Point[] points would be more obvious.

25. Adding color

Section

Section 17.2

26. Specialization adds what the library left out

Concept

Specialization is useful for adding new features to an existing class, especially when you can't (or don't want to) change its design. Polygon knows its shape and nothing about colour or drawing itself.

public class DrawablePolygon extends Polygon {
    protected Color color;

    public DrawablePolygon() {
        super();
        color = Color.GRAY;
    }

    public void draw(Graphics g) {
        g.setColor(color);
        g.fillPolygon(this);
    }
}

We can extend the Polygon class by adding a draw method and a Color attribute. Ten lines, and the result has every Polygon method plus two things Polygon does not have — which is what minimal additional code looks like.

27. What the constructor does

Notation

Three lines, and two of them restate rules from Chapter 14.

A default value is a small kindness. Leaving color null would mean g.setColor(null) on any polygon whose colour was never set — an error a long way from its cause.

28. Using the specialized class

Worked example

DrawablePolygon has the same attributes and methods that Polygon has, so nothing you learned about Polygon stops working.

DrawablePolygon p = new DrawablePolygon();
p.addPoint(57, 110);
p.addPoint(100, 35);
p.addPoint(143, 110);
p.color = Color.GREEN;

29. What does super() do here?

Prediction

DrawablePolygon's constructor calls it first.

public DrawablePolygon() {
    super();
    color = Color.GRAY;
}

30. What draw actually does

Concept

Two lines, and both of them are the graphics idiom from Chapter 15.

public void draw(Graphics g) {
    g.setColor(color);
    g.fillPolygon(this);
}

The same shape as Cell.draw in Lesson 15a: set a colour, draw something, take the Graphics as a parameter. Graphics is stateful — setColor affects every later call — which is why the colour is set immediately before use rather than once at the start.

31. Relying on the generated default constructor

Trap

public class DrawablePolygon extends Polygon {
    protected Color color;
    // no constructor

    public void draw(Graphics g) {
        g.setColor(color);      // color is null
        g.fillPolygon(this);
    }
}

public DrawablePolygon() {
    super();
    color = Color.GRAY;
}

32. Inherited or new?

Definition probe

DrawablePolygon adds two things.

33. Draw the polygon

Fill the middle

Set the colour, then fill.

34. Could you add colour without inheritance?

Counterexample

A class holding a Polygon and a Color would work too.

35. Regular polygons

Section

Section 17.3

36. Specialising the specialization

Concept

In mathematics, a regular polygon has all sides the same length and all angles equal in measure. Regular polygons are a special case of polygons, so we will use specialization to define a class for them.

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

// class RegularPolygon extends DrawablePolygon
//   which extends Polygon
//     which extends Object

We could extend the Polygon class, as we did in the previous section. But then we would not have the Color functionality we just added. So we will make RegularPolygon extend DrawablePolygon. Inheritance chains: each level keeps everything below it.

37. The trigonometry

Notation

The constructor uses trigonometry to find the coordinates of each vertex. Four steps, and the book gives all of them.

One formula, applied n times. The whole difference between a triangle and a 360-sided near-circle is the value of n — which is why the constructor takes it as a parameter rather than having three classes.

38. The RegularPolygon constructor

Worked example

Two blocks: initialise the inherited attributes, then compute the vertices.

public RegularPolygon(int nsides, int radius, Color color) {
    // initialize DrawablePolygon attributes
    this.npoints = nsides;
    this.xpoints = new int[nsides];
    this.ypoints = new int[nsides];
    this.color = color;

    // the amount to rotate for each vertex (in radians)
    double theta = 2.0 * Math.PI / nsides;

    // compute x and y coordinates, centered at the origin
    for (int i = 0; i < nsides; i++) {
        double x = radius * Math.cos(i * theta);
        double y = radius * Math.sin(i * theta);
        xpoints[i] = (int) Math.round(x);
        ypoints[i] = (int) Math.round(y);
    }
}

39. What is theta for a hexagon?

Prediction

A circle divided into six.

double theta = 2.0 * Math.PI / nsides;   // nsides = 6

40. Centred at the origin, then moved

Concept

When we construct a RegularPolygon, the vertices are centered at the point (0, 0).

RegularPolygon rp = new RegularPolygon(6, 50, Color.BLUE);
rp.translate(100, 100);

If we want the center of the polygon to be somewhere else, we can use translate, which we inherit from Polygon. Building at the origin and moving afterwards keeps the trigonometry simple — and translate was free, which is a small return on choosing to extend Polygon.

41. Working in degrees

Trap

double theta = 360.0 / nsides;          // degrees
double x = radius * Math.cos(i * theta);  // wrong

double theta = 2.0 * Math.PI / nsides;

// or, if you must start from degrees:
double theta = Math.toRadians(360.0 / nsides);

42. Where is vertex 0?

Prediction

i is zero on the first iteration.

double x = radius * Math.cos(i * theta);
double y = radius * Math.sin(i * theta);
// i = 0, radius = 50

43. Compute a vertex

Fill the middle

Cosine gives x; sine gives y.

44. What does a 360-sided polygon look like?

Edge cases

The book creates one.

45. More constructors

Section

Section 17.4

46. Chaining constructors with this(...)

Concept

Classes in the Java library often have more than one constructor for convenience. We can do the same with RegularPolygon.

public RegularPolygon(int nsides, int radius) {
    this(nsides, radius, Color.GRAY);
}

public RegularPolygon(int nsides) {
    this(nsides, 50);
}

The keyword this, when used in a constructor, invokes another constructor in the same class. It has a similar syntax as the keyword super, which invokes a constructor in the superclass. Two keywords, one idea, aimed at different classes.

47. Three constructors, one implementation

Picture it

Because we provide only one integer argument, Java calls the third constructor, which calls the second one, which calls the first one.

The result is a RegularPolygon with the specified value of nsides, 6, the default value of radius, 50, and the default color, GRAY. One implementation, three ways in — and no duplicated logic.

48. Validating the arguments

Worked example

When writing constructors, it's a good idea to validate the values you get as arguments. Doing so prevents run-time errors later in the program, which makes the code easier to debug.

public RegularPolygon(int nsides, int radius, Color color) {
    // validate the arguments
    if (nsides < 3) {
        throw new IllegalArgumentException("invalid nsides");
    }
    if (radius <= 0) {
        throw new IllegalArgumentException("invalid radius");
    }
    if (color == null) {
        throw new NullPointerException("invalid color");
    }
    // the rest of the method is omitted
}

49. What does new RegularPolygon(6) produce?

Prediction

Three constructors, chained.

public RegularPolygon(int nsides) {
    this(nsides, 50);
}
public RegularPolygon(int nsides, int radius) {
    this(nsides, radius, Color.GRAY);
}

50. Throwing an exception on purpose

Concept

Lesson 15b caught exceptions. This is the other side: creating and throwing one.

throw new IllegalArgumentException("invalid nsides");

An exception is an object, created with new like any other, and throw is the statement that sends it up the call chain. The exception type is chosen to describe the problem: IllegalArgumentException for a bad value, NullPointerException for a missing object.

51. Duplicating validation in every constructor

Trap

public RegularPolygon(int nsides) {
    if (nsides < 3) { throw new IllegalArgumentException(...); }
    this(nsides, 50);          // also checks nsides
}

public RegularPolygon(int nsides, int radius) {
    if (nsides < 3) { throw new IllegalArgumentException(...); }
    if (radius <= 0) { throw new IllegalArgumentException(...); }
    this(nsides, radius, Color.GRAY);   // checks again
}

public RegularPolygon(int nsides) {
    this(nsides, 50);                   // delegates
}

public RegularPolygon(int nsides, int radius, Color color) {
    if (nsides < 3) { throw new IllegalArgumentException(...); }
    // ... the checks live only here
}

52. this or super?

Definition probe

Two keywords that both invoke a constructor.

53. Chain and validate

Fill the middle

Default the colour; reject too few sides.

54. Why validate at all if it just crashes?

Real world

An invalid argument would probably cause a crash eventually anyway.

55. this against super

Comparison

Fill the blanks.

The last row is the one that trips people up. this is overloaded: a reference to the current object almost everywhere, and a constructor call in exactly one position — the first statement of a constructor.

56. The pattern to carry away

Pattern

Constructor chaining with validation at the end of the chain.

// the most general constructor does the work and the checking
public RegularPolygon(int nsides, int radius, Color color) {
    if (nsides < 3) {
        throw new IllegalArgumentException("invalid nsides");
    }
    ...compute the vertices...
}

// the others supply defaults and delegate
public RegularPolygon(int nsides, int radius) {
    this(nsides, radius, Color.GRAY);
}

public RegularPolygon(int nsides) {
    this(nsides, 50);
}

• Generalization pulls shared code up; specialization extends downward.
• Constructors are not inherited — a subclass writes its own and calls super().
• Math.cos and Math.sin take radians; a circle is 2π of them.
• Give every new attribute a default rather than leaving it null.
• Validate at the boundary, so failures name their cause.

57. Check: chaining

Check

Work it out before you click.

public RegularPolygon(int nsides) {
    this(nsides, 50);
}
public RegularPolygon(int nsides, int radius) {
    this(nsides, radius, Color.GRAY);
}
RegularPolygon rp = new RegularPolygon(8);

58. Check: radians

Check

Work it out before you click.

double theta = 2.0 * Math.PI / nsides;
double x = radius * Math.cos(i * theta);

59. Check: validation

Check

Work it out before you click.

public RegularPolygon(int nsides, int radius, Color color) {
    if (nsides < 3) {
        throw new IllegalArgumentException("invalid nsides");
    }
    ...
}
// the one- and two-argument constructors have no checks

60. Default arguments, the Java way

Real world

Some languages let you write RegularPolygon(int nsides, int radius = 50). Java does not.

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

Four sections that name two kinds of inheritance, then specialise a library class twice.

• Generalization extracts a superclass; specialization extends an existing class.
• Canvas and Polygon were designed to be extended — you can specialise code you have never read.
• A Polygon is npoints plus two parallel arrays, which grow by allocating and copying, like an ArrayList.
• npoints is the count; xpoints.length is the capacity — loop to the first.
• Constructors are not inherited, so a subclass writes one and usually calls super().
• theta is 2π/n, and Math.cos and Math.sin take radians.
• this(...) invokes another constructor in the same class, which is how Java does default arguments.
• Validate in the most general constructor, since every chain ends there.