1. Lecture 6 Methods and Classes
IAT 800
Lecture 6 Methods and Classes
Oct 6, Fall 2009
IAT 800

2. Today A few good programming practices Methods Classes
Rockets, asteroids
Subclasses
Methods that return values
BImage
Oct 6, Fall 2009
IAT 800

3. 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

4. Methods Methods, also known as Method declaration Method call
Functions (methods which return something)
Procedures (methods which don’t return stuff)
Method declaration
Method call
void vendingMachine( int coinCents ){ println("You inserted "+coinCents+" cents."); }
int quarter = 25; vendingMachine(quarter);
Oct 6, Fall 2009
IAT 800

5. Methods Method declaration 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…
parameter
void vendingMachine( int coinCents ){ println("You inserted "+coinCents+" cents."); }
void means doesn't return anything
Oct 6, Fall 2009
IAT 800

6. Methods Method call 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!!
argument
int quarter = 25; vendingMachine(quarter);
Oct 6, Fall 2009
IAT 800

7. Classes Types Primitives: int, float, char, boolean …
Objects: array, string, class …
Oct 6, Fall 2009
IAT 800

8. 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

9. 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

10. Fields and Methods class MySquare { int xPos, yPos; MySquare(x, y) {
xPos = x;
yPos = y; }
void drawMe() {
rect(xPos, yPos, 50, 50);
fields x y
constructor
drawMe()
(one kind of method)
methods
Oct 6, Fall 2009
IAT 800

11. Fields and Methods x y drawMe() 10 10 20 90 drawMe() drawMe() square1
class MySquare {
int xPos, yPos;
MySquare(x, y) {
xPos = x;
yPos = y; }
void drawMe() {
rect(xPos, yPos, 50, 50); 10 10 20 90
drawMe()
drawMe()
square1
square2
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
Oct 6, Fall 2009
IAT 800

12. Fields and Methods square1.drawMe(); square2.drawMe(); x y drawMe() 1020 90
square1
square2
class MySquare {
int xPos, yPos;
MySquare(int x, int y) {
xPos = x;
yPos = y; }
void drawMe() {
rect(xPos, yPos, 50, 50);
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
square1.drawMe();
square2.drawMe();
Oct 6, Fall 2009
IAT 800

13. 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

14. 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

15. 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

16. Asteroids class Asteroid { … // draw method void drawMe() {
Oct 6, Fall 2009
IAT 800

17. 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

18. Inheritance Subclasses inherit fields and methods from parent
class ArmedRocket extends Rocket { … }
Oct 6, Fall 2009
IAT 800

19. 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

20. 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

21. 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

22. 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

23. The fire() method Now add code in loop to draw missiles Missile fire(){
Missile m = new Missile(xPos, yPos, rotation);
return m; }
Now add code in loop to draw missiles
Oct 6, Fall 2009
IAT 800

24. 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