Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
310
In the BurritoRecipe class, I included three constructors, which allows the class to be initialized
three different ways, depending on what arguments are passed to the constructor
when the object is instantiated. Within the constructors’ parentheses are any optional
parameters. When you create a new object, passing arguments to a constructor, there
must be a constructor with the same number and type of parameters or the compiler will
spit out an error, which if you remember is similar to how functions work as well. The
following object instantiations are valid, based on the available constructors in the
BurritoRecipe class:
// uses default BurritoRecipe constructor
BurritoRecipe recipe1 = new BurritoRecipe();
//uses regular BurritoRecipe constructor
BurritoRecipe recipe2 = ➥
new BurritoRecipe ("spinach", "pinto", "chicken");
However, the following instantiation will generate a compiler error, as there is no constructor
with an appropriate parameter list:
// generates a compiler error.
BurritoRecipe recipe3 = new BurritoRecipe ("spinach", "chicken");
Within the code blocks (the code between the curly braces) of the bottom two constructors
are a number of assignment lines that initialize the class’s instance properties with the
values passed in via the arguments:
this.tortillaFlavor = tortillaFlavor;
this.beanType = beanType;
this.meatType = meatType;
These lines may look a little odd at first. I remember being pretty confused when I first saw
code like this. In naming the parameters, I used the same names as the properties declared
at the top of the class. This was technically not necessary, and I could have made the
names different. However, I actually find it easier to remember what parameter value
initializes what property when they have the same names. Perhaps some of you may be
thinking, “When two different things have the same name, couldn’t that create a problem,
especially if the properties declared up top have global scope and can be seen anywhere
within the class?” This is a good question. The answer is yes and no. Following, I illustrate
a good way and a bad way of performing the constructor initialization when both the
parameters and the properties have the same names.
Here’s the good code:
this.tortillaFlavor = tortillaFlavor;
this.beanType = beanType;
this.meatType = meatType;
And here’s the bad code:
tortillaFlavor = tortillaFlavor;
beanType = beanType;
meatType = meatType;