Sep 26, Fall 2006IAT 800 Lecture 6 Methods and Classes.

Sep 26, Fall 2006 IAT 800

IAT 800

Lecture 6 Methods and Classes


Today

A few good programming practices Methods Classes

– Rockets, asteroids

– Subclasses – Methods that return values– BImage


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()


Methods

Methods, also known as – 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);


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…

void vendingMachine( int coinCents ){ println("You inserted "+coinCents+" cents."); }

void means doesn't return anything

parameter


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!!

int quarter = 25;vendingMachine(quarter);

argument


Classes

Types– Primitives: int, float, char, boolean …– Objects: array, string, class …


Objects

We’ve worked with some objects before, like Arrays.

We can make our own objects, to keep related data together, and methods to control that data.


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)}


Fields and Methods

class MySquare { int xPos, yPos; MySquare(x, y) {

xPos = x;yPos = y;

}

void drawMe() {rect(xPos, yPos, 50, 50);

}}

x y

drawMe()

fields

constructor

methods

(one kind of method)


Fields and Methods

class MySquare { int xPos, yPos;

MySquare(x, y) {xPos = x;yPos = y;

}


}}

x y

drawMe()

MySquare square1 = new MySquare(10, 10);MySquare square2 = new MySquare(20, 90);

10 10

drawMe()

20 90

drawMe()

square1 square2


Fields and Methods

class MySquare { int xPos, yPos;

MySquare(int x, int y) {xPos = x;yPos = y;

}


}}

MySquare square1 = new MySquare(10, 10);MySquare square2 = new MySquare(20, 90);

x y

drawMe()

10 10

drawMe()

20 90

drawMe()

square1 square2

square1.drawMe();square2.drawMe();


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.


Asteroids

Let’s adapt this to make an array of Asteroids for our rocket from lecture.

class Asteroid { //fields float rotation = 0; float xPos, yPos; float velocityX, velocityY; long lastDrawMillis = 0; …}


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;

}


Asteroids

Class Asteroid { … // draw method void drawMe() {


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!


Inheritance

Subclasses inherit fields and methods from parent

Class ArmedRocket extends Rocket {…

}


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 call the method in the parent with the same name


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


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?


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


The fire() method

Missile fire() { Missile m = new Missile(xPos, yPos,

rotation); return m; }

Now add code in loop to draw missiles


Using the keyPressed() method

keyPressed() is a built in Processing method that is called when a key is pressed

Useful because you can tie events to keystrokes instead of to loop()– If we fire missiles in loop(), notice that we fire

many times even if we push the key quickly– This is because loop() is called many times a

second

Sep 26, Fall 2006IAT 800 Lecture 6 Methods and Classes.

Documents

Transcript of Sep 26, Fall 2006IAT 800 Lecture 6 Methods and Classes.