IAT 265 OO programming - Inheritance

1. IAT 265 OO programming - Inheritance IAT 265

2. Outline • Object-oriented programming • objects • classes • sets (mutators) and gets (accessors) • object methods • Inheritance: Subclasses • Rocket, ArmedRocket • Collections • ArrayList IAT 265

3. Inheritance IAT 265

4. Classes • Types • Primitives: int, float, char, boolean … • Objects: array, string, class … IAT 265

5. 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 265

6. 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 265

7. Fields and Methods class MySquare { intxPos, 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 265

8. x y drawMe() Fields and Methods class MySquare { intxPos, 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 265

9. x y drawMe() 10 10 20 90 drawMe() drawMe() square2 square1 Fields and Methods class MySquare { intxPos, 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 265

10. Arrays of Objects? • Let’s make a bunch of squares! MySquare[] squares = new MySquare[10]; // initialize all of our squares. for (inti = 0; i < 10; i ++) { squares[i] = new MySquare(i*10, i*10); } squares[4].drawMe(); // draw the 4th square. IAT 265

11. Recap: Rocket • Earlier, we created the Rocket class • Constructor: Rocket(intinitialX, intinitialY, float initialRot ) • Methods draw() rotateClockwise() rotateCounterClockwise() fireThrusters() IAT 265

12. Asteroids • Let’s adapt this to make an array of Asteroids for our Rocket class Asteroid { //fields float rotation = 0; float xPos, yPos; float velocityX, velocityY; long lastDrawMillis = 0; … } IAT 265

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

14. Asteroids class Asteroid { … // draw method void draw () { IAT 265

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

16. Inheritance • Subclasses inherit fields and methods from parent class ArmedRocketextends Rocket { … } IAT 265

17. 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(intinitialX, intinitialY, 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 265

18. 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 265

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

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

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

22. Missiles destroy asteroids • So far we have a rocket that flies around in a field of asteroids and fires • Now we want our missiles to blow up asteroids • This means we need a variable number of asteroids. • How do we do this with an array? • Use an ArrayList! • Also need to figure out when we have a collision IAT 265

23. The Java SDK • Java comes with thousands of classes in the Java Platform API • Documentation is available on Sun’s website • Let’s look at ArrayList IAT 265

24. ArrayList • It’s a resizeable list • Can add and delete things without worrying about declaring the size • The main methods we care about are add(), get(), and remove(), and size() • Steps in using ArrayList • Declare a variable of type ArrayList • Create a new ArrayList and assign it to the variable • Call add(), get() and remove() and size() on ArrayList as you need them IAT 265

25. Parents and children • Remember that we declared a child class ArmedRocket whose parent was Rocket • Remember that classes are types • So ArmedRocket is a type and Rocket is a type • So, here are some legal assignments • ArmedRocket r1 = new ArmedRocket(50, 60, 0); • Rocket r2 = new Rocket(50, 60, 0); • Rocket r3 = new ArmedRocket(50, 60, 0); • But this is illegal • ArmedRocket r4 = new Rocket(50, 60, 0); • Same goes for method arguments as well… IAT 265

26. Rocket Inheritance Rocket: xPos, YPos, velocityX, velocityY, rotation Rocket(x,y,rotation) draw() Inherits from ArmedRocket extends Rocket xPos, YPos, velocityX, velocityY, rotation ArmedRocket(x,y,rotation) draw() fire() IAT 265

27. Using ArrayList.add() • The argument type of the add method is Object • Object is the parent class of all classes • With an object argument type, you can pass in an object of any class • So, to initialize our asteroids… ArrayList asteroids = new ArrayList(); for(inti = 0; i < numAsteroids; i++) asteroids.add(new Asteroid()); IAT 265

28. Getting things out of an ArrayList • ArrayList.get(inti) – returns the ith object (starting with 0) • But this doesn’t work! asteroids.get(i).draw(); Why? IAT 265

29. Need to cast back from Object • Since things are put in an ArrayList as Object, they come back out as Object • It’s like they forget their more detailed type • So, when using ArrayList (or any container class), need to cast back to the more detailed type Asteroid asteroid = (Asteroid)asteroids.get(i); if (!asteroid.collision(r1)) asteroid.draw(); IAT 265

30. Pushing collision detection into the Asteroid • In the current code, detecting collision takes place in loop() • But it is cleaner (more object-oriented) if Asteroid itself knows how to detect collision • Detecting collision depends on knowing the boundaries of the asteroid, which properly belongs in the asteroid class boolean collision(Rocket r) { if ((r.xPos >= xPos - 26 && r.xPos <= xPos + 22) && (r.yPos >= yPos - 24 && r.yPos <= yPos + 26)) return true; else return false; } IAT 265

31. Destroying asteroids • When a missile hits an Asteroid, we need to destroy it • This was the whole reason for using ArrayList • Big asteroids turn into two small asteroids • Small asteroids disappear void destroy(ArrayList asteroids) { asteroids.remove(this); if (large) { asteroids.add(new Asteroid(false, xPos, yPos, lastDrawMillis)); asteroids.add(new Asteroid(false, xPos, yPos, lastDrawMillis)); } } IAT 265

32. Super and this • this is a special variable that always refers to the current instance (object) • Useful in methods to refer to yourself • this.method() – calls a method on yourself (but normally you just directly call the method) • this() – calls a constructor on yourself (useful for one version of a constructor to call another) • super is a special variable that always refers to the superclass portion of an object (the object cast into it’s superclass) • super.method() – calls the superclass’s method • super() – calls the superclass’s constructor IAT 265

33. Summary • ArrayList, a Java Platform collection class • Learned about super and subclasses as types • Any instance of a subclass is an instance of the superclass, but not visa-versa • Can cast more abstract classes (parents) into more concrete classes (children) • The Java keywords super and this • Special variables that can be used within a method to refer to yourself (the superclass portion of yourself and all of yourself) IAT 265