Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
308
// go to next line after printing
// cooking instructions to the screen
println();
}
}
Class declaration
class BurritoRecipe {
As I discussed, to declare a class, you use the class keyword followed by the identifier
(BurritoRecipe) of the class. Following the class identifier, there needs to be an open
curly brace.
Properties declaration
// properties
int size;
String tortillaFlavor;
String meatType;
String beanType;
String[]toppings;
int salsaTemperature;
Properties are declared at the top part of the class. As in previous examples with variables,
properties need a data type and a legal identifier to be declared; they can also be assigned
initial values. In this example, I just declare the properties. Notice that of the six properties,
two are of type int, three are of type String, and one is of type String[] (array of
Strings). The six declared properties are technically known as instance properties, and
each object created (or instantiated) from the BurritoRecipe class will have access to its
own unique copies of these properties. This is an important point and illustrates the blueprint
nature of classes. The properties and methods defined in the class are the core structural
elements (commonly referred to as members) of each object instantiated from the
class, and each object can express itself uniquely via its own copies of the class’s properties
and methods.
In addition to instance properties, classes can also have static properties and static methods.
These are declared with the keyword static. Static properties are also known as class
properties. I will provide an example of some static variables when I cover composition
shortly. The main difference between instance properties and static properties is that each
object or instance created from a class can assign different values to its instance properties,
but all objects of a class share the same values assigned to the class’s static properties.
In Java and Processing, static variables are used mostly to create constants (with the additional
keyword final added in the declaration). Constants are variables that are
immutable (can’t be changed). For example, in Processing and Java, PI is a constant, and
its declaration in Java’s Math package could be something like the following:
static final double PI 3.141592653589793;