Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
336
/* required method implementation
from abstract Creature superclass */
String getCreatureName(){
return "I am a Knight";
}
}
interface Archer{
void shoot();
}
/* game engine-with embedded superclass
reference in the addCreature() method
and embedded interface reference in
launchArrow method */
class Engine{
void addCreature(Creature c){
c.castSpell();
}
void launchArrow(Archer a){
a.shoot();
}
}
Sorry if the text output is anticlimactic. Later on in the book, you’ll use OOP and polymorphism
to generate some interesting visuals. In this chapter, we needed to get some theory
out of the way—which we’ve now done.
Summary
This was not an easy chapter. OOP introduces many abstract concepts to an already
abstract activity—programming. However, as you begin to create more complex sketches,
the organizational and reusability benefits of OOP make it well worth the added complexity.
Also, like any craft-based pursuit, the process gets easier through practice. The first
part of the chapter dealt with the basics of OOP—classes and objects. I think you’ll find
working with simple classes in Processing straightforward and helpful. For example, when
creating an animation, it’s helpful to encapsulate the animated object’s properties (e.g., x,
y, width, and height) inside a class, allowing you to target the properties using dot syntax
(e.g., animatedObject.x). In the advanced OOP section, you looked at some pretty complex
concepts, including inheritance, interfaces, abstract classes, and polymorphism.
Understanding and implementing these concepts takes time. Fortunately, you can do a lot
without them. However, as you build ever more complex sketches, these advanced features
can provide much greater flexibility and efficiency to your sketch design. You’ll be
using most of the features discussed in this chapter throughout the book (to accomplish
more interesting things than getting some text output).