Processing: Creative Coding and Computational Art

AXIS_VERTICAL from outside the Gradient class (or its subclasses), you’d write
Gradient.AXIS_VERTICAL; to access the value from within Gradient (or its subclass), you
can just use AXIS_VERTICAL. You can use/access static properties from within any class
without the need to instantiate an object of the class. Conversely, instance properties
require an object to be used. Another way to think about the distinction between static
and instance properties is that there is only ever a single value for any static property, but
each object has its own copy of any instance properties.
Instance properties
Below the constants, I declared some instance properties. As I just discussed, these properties
can only be accessed by an object of the class (or in this case, objects of the subclasses).
For example, if you create a RadialGradient class and then instantiate an object
using the syntax RadialGradient rg = new RadialGradient ();, you could access the
object’s c1 property with the syntax rg.c1 or rg.getColor1().
The instance property Rectangle r uses Java’s Rectangle class. This class is really handy
for holding the bounds of something. Instantiating an object of the Rectangle class takes
four arguments, defining x, y, width, and height. These public properties can then be
accessed directly, as in r.x, r.y, r.width, and r.height (assuming the Rectangle object is
named r).
Abstract method
Below the instance properties is a strange-looking method declaration:
abstract void create();
This is an abstract method, which doesn’t include any actual implementation of the
method; notice that curly braces aren’t even included. Abstract methods are used to
enforce a rule between the abstract superclass and any subclasses: a class that extends an
abstract class must implement any abstract methods within the superclass (or itself be
declared an abstract class). This means that any class that extends the Gradient class must
include a create() method—with the curly braces and preferably some gradient-creating
code between them. You are not required to include an abstract method in an abstract
class; you can just use standard implemented methods (also known as concrete methods)
like the getter/setter methods included below the abstract create() method. Subclasses
have no obligation to reimplement any concrete methods within the abstract superclass.
In the Gradient class, it made sense to make the create() method abstract, since the
code to create each gradient (linear or radial, in this case) will be radically different. In
addition, by forcing subclasses of the Gradient class to implement their own create()
method, you enforce a common interface—which is a good thing. Imagine if some company
took your Gradient class and extended it to create a library of 1,000 specialized
Gradient subclasses (and paid you gobs of money, of course). Since your superclass
requires any subclasses to implement the create() method, a user of the subclasses would
have immediate insight into how to draw any of the 1,000 custom gradients. The complicated
plotting algorithms for each gradient would be encapsulated inside the custom
implemented create() methods in each subclass—all happily hidden from the user.
COLOR AND IMAGING
471
10