IAT 800

1. IAT 800 Lecture 6 Methods and Classes IAT 800

2. Today • A few good programming practices • Methods • Classes • Rockets, asteroids • Subclasses • Methods that return values • BImage 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-formatis also your friend!! • Your programs will have at least three sections • Variable declaration • setup() • draw() IAT 800

4. 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); IAT 800

5. void means doesn't return anything 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."); } 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); IAT 800

7. Classes • Types • Primitives: int, float, char, boolean … • Objects: array, string, class … 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. 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) } 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 IAT 800

11. x y drawMe() Fields and Methods 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); IAT 800

12. x y drawMe() 10 10 20 90 drawMe() drawMe() square2 square1 Fields and Methods 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(); 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. 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; … } 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; } IAT 800

16. Asteroids class Asteroid { … // draw method void drawMe() { 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! IAT 800

18. Inheritance • Subclasses inherit fields and methods from parent class ArmedRocket extends Rocket { … } 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 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 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? 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 IAT 800

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

24. Using the keyPressed() method • keyPressed() is a built in Processing method that is called when a key is pressed IAT 800