Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
332
Returning to the creature engine example, let’s say some of the creatures have archery
capabilities. It would be possible to add archery capabilities directly within the Creature
class (which each class extends), but of course not all creatures would be archers, so it
really doesn’t belong in the Creature superclass. Another possible option might be to
create a new Archer class, but the problem there is that you’re not allowed to have a class
in Processing/Java extend more than one class. Since each creature needs to extend the
Creature class, it wouldn’t be possible to also extend the Archer class. Using an interface
can help solve this problem. As discussed, an interface can only include constants and
unimplemented methods (method signatures). Here’s a very simple Archer interface:
interface Archer{
void shoot();
}
This interface only includes a shoot() method; notice the absence of curly braces following
the shoot() method signature. To use the interface, you need to add the implements
keyword along with the interface name to the end of another class declaration. I’ll add the
interface to the Elf class and also to a new Knight class. Here’s what the class declaration
statements look like:
class Elf extends Creature implements Archer
class Knight extends Creature implements Archer
And here are the completed Elf and Knight classes:
// Elf class
class Elf extends Creature implements Archer{
void castSpell(){
println("Gotta make the cookies");
}
// required method from interface
void shoot(){
println("Elf shoots");
}
}
//Knight class
class Knight extends Creature implements Archer{
void castSpell(){
println("Mirror, mirror on thw wall...");
}
// required method from interface
void shoot(){
println("Knight shoots");
}
}
Notice that both classes contain the shoot() method, including their own unique implementations.
It’s important to remember that any class that implements an interface is