Goals

• Understanding Methods
  • Creating Custom Methods
  • Adding Parameters
  • Returning
  • Overloading Methods
  • Variable Scope

Resources

http://processing.org/learning/basics/functions.html

Creating Methods

In addition to setup and draw Processing allows us to define our own methods. This provides two important features:

• We can separate our code
• We can execute our code multiple times (with different arguments)

Methods are composed of a few parts:

• Return Type: specifies what type of value will be returned (void for nothing)
• Method Name: must be unique (there are exceptions)
• Parameters: a list of variables with their type used in the method
• Method Body: the code that the method executes

Calling Methods

We tell a method to execute its code by calling it. Calling methods is a simple one line statement.
drawStar(); calls the method named drawStar
Can you see why all methods must have a unique name?

Here is an example of the drawStar method in action:

void setup() { size(400, 400); background(255); //Call our method drawStar(); } void drawStar() { stroke(0, 128); strokeWeight(4); fill(255, 0, 0, 128); pushMatrix(); translate(width/2, height/2); beginShape(); //a list of verticies for our star vertex(0, -160); vertex(-60, -80); vertex(-160, -80); vertex(-60, -20); vertex(-160, 100); vertex(0, 20); vertex(160, 100); vertex(60, -20); vertex(160, -80); vertex(60, -80); endShape(CLOSE); popMatrix(); }

Adding Parameters

We can add some variables to our method so when we make a method call we can specify certain parameters of how the method should behave. There are two parts to parameters:

• A type
• Each parameter must specify its own type
• There are no shortcuts
• A name
• Each name should be unique
• Do not use the same names as global variables

Arguments

In order to use the parameters of a method, we must call the method with the same amount and types of data. The values you put in a method call are referred to as arguments. The arguments must always match the parameters of a method.
Draw star method with parameters:
void drawStar(int x, int y, float startScale);
Calling draw star with arguments:
drawStar(width/2, height/2, 0.2);

Here is an example of the drawStar method with parameters:

void setup() { size(400, 400); background(255); //Call our method drawStar(width/2, height/2, 0.4); //arguments: width/2, height/2, 0.4 drawStar(100, 100, 0.2); //arguments: 100, 100, 0.2 drawStar(300, 300, 0.3); //arguments: 300, 300, 0.3 } void drawStar(int x, int y, float starScale) { stroke(0, 128); strokeWeight(4); fill(255, 0, 0, 128); pushMatrix(); translate(x, y); //using parameters x,y scale(starScale); //using parameter starScale beginShape(); //a list of verticies for our star vertex(0, -160); vertex(-60, -80); vertex(-160, -80); vertex(-60, -20); vertex(-160, 100); vertex(0, 20); vertex(160, 100); vertex(60, -20); vertex(160, -80); vertex(60, -80); endShape(CLOSE); popMatrix(); }

Returning from a Method

Every method will return to where the method was called once it has finished executing its code. This means that the last line of code in the method body has been executed.

There is something else methods can do however, they can return a value. A method that returns nothing specifies a return type of void. Here are some examples:

int add2ints(int x, int y); will return an int
float add2floats(float x, float y); will return a float
boolean lightIsOn(); will return a boolean
apples[] getBagOfApples(); will return an array of apple objects

When a method specifies the type of value it will return, it must return that value somewhere in the method body. This is accomplished by using the special keyword return.

return x + y; returns the sum of x and y
return true; returns the boolean value true
return new apples[5]; returns an uninitialized array of apple objects

When the return statement is reached in the method body, any code after will not be executed. Return literally returns to where the method was called, leaving the method and any code after not reached. Here is a live example of some method returning:

void setup() { size(120, 120); background(255); fill(0); text( add2ints(5, 5), 50, 50 ); text( add2floats(4.999, 5.0001), 50, 70 ); text( sayHi(), 50, 90 ); } int add2ints(int x, int y) { return x + y; } float add2floats(float x, float y) { return x + y; } String sayHi() { return "Hello"; text( "This will never be printed", 50, 50 ); }

Method Overloading

Methods must all have a unique name. While this is only partially true, it is important to know that a method's name really includes more than simply the method name itself.

A method signature is the method name plus the method's parameters. So two methods can share the same name, but specify different parameters. Here are some examples:

int addInts(int x, int y);
int addInts(int x, int y, int z);
int addInts(int x, int y, int z, int w);

Notice how all of these methods share the same return type and name, however, their parameters are different. Since both the name and the parameters make up the method signature, it is true that all methods must have a unique signature, otherwise Processing will not know which method to call.

Here is an example of overloading:
(Processing.js cannot overload methods, but try this example in regular Processing)

void setup() { size(120, 120); background(255); fill(0); text( addInts(5, 5), 50, 50 ); text( addInts(5, 5, 5), 50, 70 ); text( addInts(5, 5, 5, 5), 50, 90 ); } int addInts(int x, int y) { return x + y; } int addInts(int x, int y, int z) { return x + y + z; } int addInts(int x, int y, int z, int w) { return x + y + z + w; }

Variable Scope

Since methods are separated blocks of code. When you declare a variable inside a method, the scope of that variable is the method body. This means that the variable does not exist outside the method. Let's look at an example:

void setup() { size(140, 140); background(255); fill(0); text( addInts(5, 5), 50, 50 ); //text(sum, 50, 90); //will NOT work here } int addInts(int x, int y) { int sum; //declare a new int sum sum = x + y; //initialize sum to x + y text(sum, 50, 70); //will work here return sum; //return from the method } //text(sum, 50, 110); //will NOT work here

Variable scope is an important topic that we will discuss in more detail in relation to objects.

void setup() { size(400, 400); background(255); } void draw() { if (keyPressed) { if (key == ' ') { background(255); } } if (mousePressed) { float mouseVelocity = dist(mouseX, mouseY, pmouseX, pmouseY); float mouseAngle = atan2(mouseY - pmouseY, mouseX - pmouseX) + PI/2; drawStar(mouseX, mouseY, mouseAngle, mouseVelocity/128 ); } } void drawStar(int starX, int starY, float starAngle, float starScale) { stroke(0, 128); strokeWeight(4); fill(255, 0, 0, 128); pushMatrix(); translate(starX, starY); rotate(starAngle); scale(starScale); beginShape(); vertex(0, -160); vertex(-60, -80); vertex(-160, -80); vertex(-60, -20); vertex(-160, 100); vertex(0, 20); vertex(160, 100); vertex(60, -20); vertex(160, -80); vertex(60, -80); endShape(CLOSE); popMatrix(); }