Processing: Creative Coding and Computational Art

a Window object argument */
House(Window win){
this.win = win;
}
// other House methods would go here
}
From within Processing, I could use these classes like this (assuming, of course, that the
two classes were pasted below the setup() function, or each in their own separate tab):
void setup(){
Window myWin = new Window(4, true, Window.ELLIPTICAL);
House myHouse = new House(myWin);
}
OBJECT-ORIENTED PROGRAMMING
Notice that I included three constants in the Window class. It is a coding convention to use
all caps for constant names. One of the most common uses for constants is for preset
values. In my example, I am giving a user of the Window class a choice of three different
window configurations. I could have just forced the user to type in a number, but it is easier
for most people to remember a name. In my Window class, I would eventually want to
add a method that figures out what constant the user selected (which is just an int value),
and then have that type of window created. You’ll notice in the Processing setup() function
that I use the static ELLIPTICAL property by attaching it to the class name with a dot
(Window.ELLIPTICAL). Static properties are class properties that are accessible from any
class. There is no need to instantiate an object of the class to use them. Remember also
that Processing and Java are case sensitive, so when using the class name, you need the initial
capital.
After the static properties, I declare three instance properties, which should hopefully look
familiar by now. Next, in the Window constructor, I do my normal parameter-to-property
assignments. I didn’t include any other methods in the class for the sake of brevity (as if
that were still possible).
The House class is very short, but gives a clear example of class composition. I only
declared one instance variable, and you’ll notice it is of type Window. Now this may look
pretty odd, as you normally declare a property or variable as a valid data type, built into
the Processing and Java core languages. Well, it so happens that any class you create is a
valid data type. The subtlety of this concept took me some time to fully grasp. Just remember
that a class is a data type. So it is perfectly valid to declare a property of a class type.
In the House constructor, there is a parameter of type Window that requires that an argument
of type Window be passed in when a House object is instantiated. Within the House
constructor, I do a standard assignment, using the parameter and property—both of type
Window. The really cool thing is that now I can communicate directly with the Window
object from within the House class, through its internal reference passed into the House
constructor. Of course, if I were to finish the class, I would want to include additional
properties and methods, allowing the Window object to be placed and sized within the
house.
325
8