Processing: Creative Coding and Computational Art

Advanced OOP concepts
Next, I’ll introduce some advanced OOP concepts, including encapsulation/information
hiding, inheritance, composition, interfaces, and polymorphism. These concepts are fundamental
to OOP, but they’re somewhat difficult to grasp and even harder to effectively
apply. Understanding these concepts becomes increasingly important as your projects
increase in size and complexity, especially when you want to create reusable code. If
you’re a new coder (and are still recovering from the basic OOP whirlwind tour), you
might want to skip this next section (for now). Just be sure to return to it, as you’ll definitely
want to know about this stuff to fully leverage the power of Processing and Java.
Fortunately, you can learn these concepts incrementally as you progress as a coder. It’s
also possible, if you’re anything like me, that you may end up finding this stuff fascinating.
Encapsulation and data hiding
Encapsulation is one of the more “slippery” terms you’ll stumble across when you begin to
learn programming. On the one hand, its meaning in programming is similar to its meaning
in English—the encasing or enclosing of something. You can think about the way a
function encases lines of code into an invokable unit as a form of encapsulation. One of
the benefits of this arrangement is that the interface to a function and the implementation
within the function are separated; this allows the implementation to change over time
while still maintaining a consistent interface. For example, if I have a function called
createPortrait() that initially draws a lousy stick-figure head, over time I can improve
the algorithm to generate a more photorealistic head. The user, then, can just keep calling
createPortrait() as the interface to the function remains constant, in spite of the
improvements made to the guts of the function.
In OOP, encapsulation refers to the encasing and grouping of an object’s data fields (properties)
with its methods. As mentioned earlier, objects are created from classes, each with
its own copies of the properties and methods defined in the class. In classic OOP, you don’t
generally interact with an object’s properties directly. Instead, you use the object’s methods
to get or set its property values. This principle is referred to as data or information
hiding. In Java, for example, you normally use the keyword private when declaring properties
to make them inaccessible. You declare methods (which are the structures that users
of the class must use to interact with the properties) as public to get and set their values.
For example, if I have class that has a name property, I would declare the property as private
like this:
private String name;
And I would create public get and set methods to provide indirect access to the private
name property, as follows:
public String getName (){
return name;
}
public void setName (String n){
name = n;
}
OBJECT-ORIENTED PROGRAMMING
319
8