Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
330
//subclass 2
class Elf extends Creature{
void castSpell(){
println("Gotta make the cookies");
}
}
/* game engine--with embedded superclass
reference in the addCreature() method */
class Engine{
void addCreature(Creature c){
c.castSpell();
}
}
In the example, the Ogre and Elf classes each extend the Creature class. Through this
inheritance relationship, any Ogre and Elf objects instantiated will now also be of the secondary
type Creature. Thus, it would be perfectly legal to assign new Ogre and Elf objects
to variables declared of type Creature.
Creature o = new Ogre();
Creature e = new Elf();
However, as you continue to expand this example, you’ll want the Ogre and Elf objects to
be assigned to variables of type Ogre and Elf, respectively—so if you tried using the preceding
superclass assignment lines (which would work for now), make sure you put them
back to what they were:
Ogre o = new Ogre();
Elf e = new Elf();
This capability of unrelated objects (created from different classes) to have a relationship
through a common parent class (which each class extends) allows you to create moreflexible
programs. For example, if you create a game that includes the Ogre and Elf creatures,
inside the game engine you’d either have to hard-code reference variables for each
of the creatures, or use a common extended class. For only two creatures, either option
might be fine. However, what if your game included 20 creatures, or even the capability
for players to create their own creatures? The last thing you’d want to do is to keep going
into your game engine code and adding new reference variables every time a player created
a new creature. Rather, by including a common superclass reference variable in your
engine, you could simply require players creating a new creature class to extend your base
Creature superclass. This would allow your game to scale up, without you’re ever having
to touch the game engine source code.
Besides including a reference to the superclass in your game engine, you’d also need common
methods within the Creature superclass and all the individual subclasses. In my last
example, notice the common castSpell() method within the Creature superclass and
both the Ogre and Elf subclasses. These methods have identical signatures (same name
and parameter list). However, their implementations (the code between the curly braces
of the methods) are different. As I mentioned earlier, one of the benefits of inheritance is