Processing: Creative Coding and Computational Art

Inheritance
In OOP, inheritance describes the ability of one class to inherit, or extend, the attributes
and capabilities of another class. For example, if I create a class called Box, I could give it
attributes such as height, width, depth, x, y, color, and so forth. It might also have methods
to get and set these properties, and perhaps a create() method. I could then use this
Box class as the base for another class or even a set of classes. A house, a cage, and a suitcase
are all radically different objects, yet they each rely on a box structure. Instead of
each of these classes defining their own height, width, depth, x, y, and color properties,
they could inherit these from the Box class.
In Processing and Java, when a class inherits form another class, the term extends is used
to describe the relationship of one class inheriting from another. In addition, the term
superclass is used to describe the class being extended from, and subclass is used to
describe the class that extends the superclass. In the box example, Box would be the
superclass and House, Cage, and Suitcase would each be subclasses of Box; it is also said
that each of these subclasses extends the Box class. When a class extends a class, besides
having access to the properties and methods in the superclass, the subclass can add its
own additional properties and methods that would be unique to the class. For example,
the House class, besides having the general properties of a box, might also have a roof
property, a chimney property, and so on. There are some additional subtle and advanced
concepts involved in inheritance, which I’ll look at in the next few chapters. However, for
now, I’ve created a sketch that illustrates basic inheritance. The sketch reuses the linear
and radial gradient examples from earlier in the chapter, with some minor modifications.
Gradient class
The first class I designed for this example was a Gradient class. This class will be the base
class for a LinearGradient class and also a RadialGradient class. In other words, the
Gradient class will be the superclass, and the LinearGradient and RadialGradient subclasses
will extend the Gradient class. In addition, in thinking about these class relationships,
I decided that I didn’t want people to be able to directly use the Gradient class (i.e.,
instantiate the class), but rather only use it as a superclass for building other types of custom
gradients. Java has a keyword (abstract) that is used to enforce this condition (which
Processing has access to) that I have included in the Gradient class. Here’s the class
(please note that this class, as well as the individual subclasses I’ll look at shortly, are not
intended to be run independently):
abstract class Gradient {
// constants
// these can't be changed
final static int AXIS_VERTICAL = 0;
final static int AXIS_HORIZONTAL = 1;
// instance fields with default values
// these can be changed
color c1 = color(255);
color c2 = color(0);
Rectangle bounds = new Rectangle(0, 0, width, height);
COLOR AND IMAGING
469
10