Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
684
Example 3: Using Processing’s append() function on an
array of objects
// type casting required
void setup(){
SimpleClass[] sc = {new SimpleClass(), new SimpleClass(), ➥
new SimpleClass()};
println("sc length before append = " + sc.length);
// I need to explicitely cast the returned Object array ➥
to a SimpleClass array
sc = ((SimpleClass[])append(sc, new SimpleClass()));
print("sc length after append = " + sc.length);
}
class SimpleClass{}
This third example requires some understanding of OOP, which is covered in detail in
Chapter 8.
The last line in the example is the definition for a class (which has no capabilities at all, but
is a valid class nonetheless). Since a class is a legal data type, it’s OK for me to declare an
array of type SimpleClass, as I did in this line:
SimpleClass[] sc = {new SimpleClass(), new SimpleClass(), ➥
new SimpleClass()};
I also filled the array with three SimpleClass objects when I declared it. Every time new
SimpleClass() is called, a SimpleClass object is returned between the curly braces. Thus,
the sc array holds three SimpleClass object references. The first println() statement
confirms this. Next, I call Processing’s append() function, which is where the type casting
occurs. If I had tried to call the append() function as I did in the previous example—like
this:
sc = append(sc, new SimpleClass());
I’d get an error to the effect that I can’t assign an array of type Object to a variable of
type SimpleClass[]. The reason that the append() function converts the original
SimpleClass[] array to type Object relates to how the append() function works internally,
which I won’t go into. The way to fix this type mismatch is to explicitly type cast the
Object array back to SimpleClass[], as I did in this line:
Control
sc = ((SimpleClass[])append(sc, new SimpleClass()));
The Control section includes 18 entries divided in four sections. Control elements in
Programming are the logic constructs that control how a program flows, as well as, in the
case of loops, the data processing mechanisms supplying power and iterative efficiency.