Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
326
There are many advantages for House and Window to have this special compositional relationship.
By letting the house control when and where to draw the windows, it can ensure
that the windows always fit, regardless of whether the house is resized or moved. By letting
the windows take care of actually drawing themselves, the house only has to worry
about the number of windows, their scale, and where they go. This is good, clean OOP in
action.
I realize that this is not easy stuff to grasp in its entirety, but I hope you are getting a sense
of what OOP is and why it might be useful. The best way to learn OOP is to practice and
experiment writing classes/programs. You can read this stuff over and over, but until you
apply it, it’s hard to get it to stick. The final concepts we’ll look at in this long chapter are
not easy, so read at your own risk. If you choose to jump ahead, which is fine, do try to
come back at some point.
Interfaces
In the example on inheritance a couple of pages back, a Polygon class extended a Shape
class. This allowed the Polygon class to access the class members of the Shape class. This
made sense because of the is-a relationship. A polygon is a shape. In the composition
example, the House class contained a reference to the Window class through an instance
variable of type Window. This was the right solution because a house has a window, but a
window is not a house. I could have also used the Shape class as a base class for both the
House and Window classes, as both a window and a house are shapes (of a sort). It is possible
and actually very common to combine inheritance and composition when designing
classes.
However, there are times when you’ll have a class that has an is-a relationship to two or
more classes. For example, a Bicycle class could have an is-a relationship to a Vehicle
class and also a SportsGear class. Since the SportsGear class and the Vehicle class don’t
have much in common, you can’t logically create an inheritance chain, where the Bicycle
class extends the SportsGear class that extends the Vehicle class. The most logical solution
is one of multiple inheritance, where the Bicycle class extends both the Vehicle class
and the SportsGear class. In a language like C++, this could be done. However, in Java and
Processing, this is illegal, as the languages don’t support multiple class inheritance, which
many people think is a good thing. If you want to learn more about this issue, check out
www.javaworld.com/jw-12-1998/jw-12-techniques.html. However, Java/Processing does
support another approach to multiple inheritance, often referred to as multiple inheritance
of interface.
Interfaces are class-like constructs that can only include method definitions and constants.
Interfaces can’t include method implementations, the stuff between the curly braces.
Method definitions include a return type (or the keyword void), the identifier (name) of
the method, and the number and type of parameters. For example, method definitions in
a SportsGear interface might include the following:
String getBrandName();
float getUnitCost();
void setUnitCost(float unitCost);
void printWarranty();