Processing: Creative Coding and Computational Art

gle), and so on. These unique attributes would be defined within the specific Rectangle,
Circle, and Triangle classes.
The ability for classes to extend other classes is a powerful feature of OOP, allowing
libraries of classes to be developed for reuse. For example, if I create a simple drawing
program, I could incorporate the existing Rectangle, Circle, and Triangle classes just
discussed, rather than rebuilding from scratch. Most programming languages come with
extensive libraries of classes, greatly simplifying the development process. Processing takes
this concept one step further by creating a procedural front-end (allowing you to simply
call functions) on top of the classes it relies on. The Java language, which you’ll work with
toward the end of the book, is a great example of a mature object-oriented language with
thousands of prewritten classes at your disposal.
Now these are a lot of new concepts to absorb without any pictures (or at least code snippets),
so let’s get to work with some code. Following is an OOP example, based on the
creation (and hopefully consumption) of a Burrito class.
BurritoRecipe class
OBJECT-ORIENTED PROGRAMMING
Classes are often used to model specific objects or processes in the real world. I like burritos
quite a bit—so let’s make a BurritoRecipe class. Since a class is composed of properties
and methods, you need to think about what properties or characteristics a burrito
recipe has and what methods or actions would be associated with a burrito recipe. I know
this sounds very simplistic, but this really is classic object-oriented thinking.
In OOP, you create an abstraction (the class), internally grouping the class’s properties with
methods that act upon these properties, raising program design issues to a higher level
where you can think like a person (albeit a hungry person), rather than like a machine. For
example, once you create your BurritoRecipe class, you could use it by writing something
like burritoRecipe1 = new BurritoRecipe(). If you wanted to select pinto beans for your
recipe, you could then write something like burritoRecipe1.setBeans("pinto"). Classes
are often also thought of as blueprints. You use the blueprints to make objects (also
known as instances) of the class. For example, the aforementioned burritoRecipe1 is an
object of the BurritoRecipe class. Each object created from a class has access to the same
structure (the class’s internal properties and methods), but each object can also choose to
express itself differently from other objects derived from the same class. Thus, I can use
the BurritoRecipe class to make a bean burrito recipe, and you can use it to make a
chicken burrito recipe (or better yet, a chicken and bean burrito recipe).
Here are some BurritoRecipe properties: size, tortillaFlavor, meatType, beanType,
toppings, salsaTemperature.
Here are some Burrito methods: getSize(), setSize(), getTortillaFlavor(),
setTortillaFlavor(), setMeatType(), getMeatType(), setBeanType(), getBeanType(),
getToppings(), setToppings(), setSalsaTemperature(), getSalsaTemperature(), and
printRecipe(). It is the convention, where applicable, to create get and set methods for
the class’s properties. In the preceding list of methods, all of the methods except
printRecipe() either get or set properties of the class.
303
8