Processing: Creative Coding and Computational Art

void setup(){
size(400, 400);
background(50);
smooth();
Polygon p = new Polygon(0, 0, 175, 175, 8);
translate(width/2, height/2);
p.create();
}
One final point: Processing and Java allow a superclass to be assigned an object reference
to any class that has extended it or is below it in the inheritance lineage. Thus, an object of
the Object class can be assigned an object reference to any class, because the Object class
sits alone at the very top of the entire class lineage. So it is perfectly legal and common to
write a statement like this:
Shape myShape = new Polygon(10, 19, 233, 100, 8);
Inheritance gives Processing and Java a lot of power, efficiency, and flexibility. Applying it
judiciously, however, is not always so simple. One of the potential problems with inheritance
is that classes get locked into dependencies. So, if I eventually decide to change a
class for reuse, I may inadvertently mess up another program that depends, through inheritance,
on a certain implementation within a superclass. This scenario and how to deal with
it is a pretty advanced and subtle concern that won’t apply to most new coders, but it is
something to keep in the back of your mind as you begin to develop larger and more
complex projects.
Composition
OBJECT-ORIENTED PROGRAMMING
One alternative (and also complimentary) approach to inheritance is called composition.
Composition is another technique for developing relationships between classes. Composition
is pretty straightforward to implement, and I think easier to get your head around than
inheritance. Let’s imagine I’m trying to develop a virtual house. My house will be really
simple; it will only contain windows. The windows, however, are pretty fancy. In OOP, it is
virtuous to be able to modularize a construct into a class, encapsulating its properties and
behavior. Thus, it would be a good idea to create a Window class and have the class internally
take care of creating and customizing the windows. Then, in my House class, I could
just worry about where the windows are going to go and maybe how big to scale them; the
Window class would take care of everything else. This is good OOP design. However, this
approach also involves having multiple classes interacting with one other. The challenge of
this inter-class communication is that unless there is an inheritance relationship, an object
from one class can’t effectively communicate with an object of an unrelated class. In my
previous inheritance example, the Polygon class extended the Shape class. This made
sense because a polygon is a type of shape. Can I do the same thing with the House and
Window? Not really, as a window is not a type of house. Thus inheritance doesn’t conceptually
seem like the right choice.
323
8