IAT 800
Lecture 6 Methods and Classes
Oct 6, Fall 2009
IAT 800
Today
A
few good programming practices
 Methods
 Classes
– Rockets, asteroids
– Subclasses
– Methods that return values
– BImage
Oct 6, Fall 2009
IAT 800
Good Practices

Comments are your friend!
– Put a block of commenting at the top of each
program that explains what it does
– Comment in code what a section will do
– Comment when you appropriate code!!
Auto-format is also your friend!!
 Your programs will have at least three sections

• Variable declaration
• setup()
• draw()
Oct 6, Fall 2009
IAT 800
Methods
 Methods,
also known as
– Functions (methods which return something)
– Procedures (methods which don’t return stuff)
 Method
declaration
void vendingMachine( int coinCents ){
println("You inserted "+coinCents+" cents.");
}
 Method
call
int quarter = 25;
vendingMachine(quarter);
Oct 6, Fall 2009
IAT 800
Methods
 Method
declaration
parameter
void vendingMachine( int coinCents ){
println("You inserted "+coinCents+" cents.");
}
void means
doesn't return
anything
• The method declaration is like a blueprint
• Doesn't matter if declaration is before or after call!
• Parameter name (e.g. coinCents) is just the name
given to data passed into the method…
Oct 6, Fall 2009
IAT 800
Methods
 Method
call
argument
int quarter = 25;
vendingMachine(quarter);
• vendingMachine(quarter) == vendingMachine(25)
• Method call must occur in either setup(), draw(),
or another method…
• You can call it as many times as you like!
– vendingMachine()s for everyone!!
Oct 6, Fall 2009
IAT 800
Classes
 Types
– Primitives: int, float, char, boolean …
– Objects: array, string, class …
Oct 6, Fall 2009
IAT 800
Objects
 We’ve
worked with some objects before,
like Arrays.
 We can make our own objects, to keep
related data together, with methods to
control that data.
Oct 6, Fall 2009
IAT 800
Classes
 Classes
are the blueprints for our new
objects.
 To declare a new Class (a new type of
object):
class MyToy {
// fields (class variables)
// methods (class functions)
}
Oct 6, Fall 2009
IAT 800
Fields and Methods
class MySquare {
int xPos, yPos;
MySquare(x, y) {
xPos = x;
yPos = y;
}
}
fields
constructor
y
drawMe()
(one kind
of method)
void drawMe() {
rect(xPos, yPos, 50, 50);
}
Oct 6, Fall 2009
x
methods
IAT 800
Fields and Methods
x
class MySquare {
int xPos, yPos;
drawMe()
MySquare(x, y) {
xPos = x;
yPos = y;
}
}
y
10 10
void drawMe() {
rect(xPos, yPos, 50, 50);
}
drawMe()
square1
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
Oct 6, Fall 2009
IAT 800
20 90
drawMe()
square2
Fields and Methods
x
class MySquare {
int xPos, yPos;
drawMe()
MySquare(int x, int y) {
xPos = x;
yPos = y;
}
}
10 10
drawMe()
void drawMe() {
rect(xPos, yPos, 50, 50);
}
square1
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
square1.drawMe();
square2.drawMe();
Oct 6, Fall 2009
y
IAT 800
20 90
drawMe()
square2
Arrays of Objects?
 Let’s
make a bunch of squares!
MySquare[] squares = new MySquare [10] ;
// initialize all of our squares.
for (int i = 0; i < 10; i ++) {
squares[i] = new MySquare(i*10, i*10);
}
squares[4].drawMe(); // draw the 4th square.
Oct 6, Fall 2009
IAT 800
Asteroids
 Let’s
adapt this to make an array of
Asteroids for our rocket from lecture 4
class Asteroid {
//fields
float rotation = 0;
float xPos, yPos;
float velocityX, velocityY;
long lastDrawMillis = 0;
…
}
Oct 6, Fall 2009
IAT 800
Asteroids
 When
we create an asteroid, let’s have it
start in a random position, and move in a
random direction.
class Asteroid {
…
// constructor
Asteroid() {
xPos = random(0, 400);
yPos = random(0, 400);
rotation = random(0, TWO_PI);
velocityX = sin(rotation)*10;
velocityY = -cos(rotation)*10;
}
Oct 6, Fall 2009
IAT 800
Asteroids
class Asteroid {
…
// draw method
void drawMe() {
Oct 6, Fall 2009
IAT 800
Revisit our example

So far we have a rocket that flies around in a
field of asteroids

What if we want our rocket to be able to fire
– But we don’t want to get rid of our non-firing rocket

Create a subclass!
Oct 6, Fall 2009
IAT 800
Inheritance
 Subclasses
inherit fields and methods
from parent
class ArmedRocket extends Rocket {
…
}
Oct 6, Fall 2009
IAT 800
Our subclass needs a
constructor

Our empty ArmedRocket example creates an error
– Processing doesn’t know how to construct an ArmedRocket

We want the ArmedRocket constructor to do the same
work as the Rocket constructor
ArmedRocket(int initialX, int initialY, float initialRot) {
super(initialX, initialY, initialRot);
}
The keyword super means to refer to the parent class.
In this case, to call the Parent Class Constructor
Oct 6, Fall 2009
IAT 800
Now we have ArmedRocket
 We
can use an ArmedRocket now in our
example
 But,
it’s basically just a copy of Rocket
 The
only reason to define an
ArmedRocket is to add new capabilities or
to override old ones
Oct 6, Fall 2009
IAT 800
Add a fire() method
 We
want our fire method to draw a
missile that shoots out of the rocket
 We
could have the fire method draw the
missile…
– Is there a problem with this?
Oct 6, Fall 2009
IAT 800
Missiles should also be objects

The object oriented solution is to make the missile an
object as well
– All the different types of “things” in our domain should
have a corresponding class

Like asteroids and rockets, the missile class should know
how to draw itself
– A Missile is similar to a rocket (position, rotation, draw
method, etc.)

Now our ArmedRocket.fire() method can just create and
return a missile
Oct 6, Fall 2009
IAT 800
The fire() method
Missile fire()
{
Missile m = new Missile(xPos, yPos, rotation);
return m;
}
 Now
Oct 6, Fall 2009
add code in loop to draw missiles
IAT 800
Using the keyPressed() method
 keyPressed()
is a built in Processing
method that is called when a key is
pressed
Oct 6, Fall 2009
IAT 800