IAT 334 OO programming - PowerPoint PPT Presentation

iat 334 oo programming n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
IAT 334 OO programming PowerPoint Presentation
Download Presentation
IAT 334 OO programming

play fullscreen
1 / 53
IAT 334 OO programming
121 Views
Download Presentation
ziazan
Download Presentation

IAT 334 OO programming

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. IAT 334 OO programming IAT 334

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

  3. Parts of a class • Classes define fields, constructors and methods • Fields are the variables that will appear inside every instance of the class • Each instance has its own values • Constructors are special methods that define how to build instances (generally, how to set the initial values of fields) • Methods are how you do things to instances IAT 334

  4. Defining the rocket class class Rocket { // fields float rotation = 0; float xPos; float yPos; final inthalfWidth = 10; final inthalfHeight= 10; // constructor Rocket( intinitialX, intinitialY, float initialRot ) { xPos = initialX; yPos = initialY; rotation = initialRot; } } IAT 334

  5. Using the class to create instances • Classes define a type • You can now declare variables of this type and initialize them using the constructor • Like arrays, the keyword new is used to tell Java to create a new object Rocket r1, r2 ; void setup() { r1 = new Rocket(75, 10, 0); r2 = new Rocket(50, 50, PI/2); } • Nice, but my rockets don’t do anything (need methods!) IAT 334

  6. Adding a draw routine to our Rocket No Arguments! void draw() { pushMatrix(); translate(xPos, yPos); rotate(rotation); triangle(0, -halfHeight, -halfWidth, halfHeight, halfWidth, halfHeight); rectMode(CORNERS); rect(-halfWidth + 5, halfHeight, -halfWidth + 8, halfHeight + 3); rect(halfWidth - 8, halfHeight, halfWidth - 5, halfHeight + 3); popMatrix(); } Don’t need arguments because we use the fields But we could define additional arguments if we wanted to IAT 334

  7. Calling methods on objects • You call methods on instances • Think of the method as something you are asking the object to do • For example, we can now ask the rockets to draw themselves r1.draw(); • In general, to call a method, take the name of the variable holding the object + “.” + the method name myObject.myMethod(); IAT 334

  8. Objects IAT 334

  9. Real Objects • Real-world objects have • State • Behavior • Bicycle • State • selected gear, current pedal cadence, speed • Behavior • Change Gear, Set Cadence, Apply Brakes IAT 334

  10. Software Object • State int gear ; float speed ; float cadence ; • Behavior ChangeGears(int g); Brake( float level ); ChangeCadence( float c ); int GetGear(); float GetSpeed(); … IAT 334

  11. Java directly supports Objects • Java has direct syntactic and semantic support for Objects Syntax: class Bicycle { privateint cadence = 0; privateint speed = 0; privateint gear = 1; void changeCadence(intnewValue) { cadence = newValue; } void changeGear(intnewValue) { gear = newValue; } } IAT 334

  12. Java directly supports Objects • Java has direct syntactic and semantic support for Objects Semantics: class Bicycle { privateint cadence = 0; privateint speed = 0; privateint gear = 1; void changeCadence(intnewValue) { cadence = newValue; } void changeGear(intnewValue) { gear = newValue; } } Only these methods can read or write Bicycle private data IAT 334

  13. Java Semantic support • Programming usually takes place with objects: ClockThingclock = new ClockThing(); clock.setSecond( 12 ); clock.setMinute( 18 ); clock.setHour( 3 ); IAT 334

  14. Even Arrays are objects int[] bob = new int[10] ; bob[4] = 123 ; println( bob.size() ); Bicycle[] bikes = new Bicycle[10] ; bikes[0] = new Bicycle(); IAT 334

  15. Sets and Gets • what can you do with private data? • to set it: setVarName( varType newValue) • to get it: varType getVarName() • Why? IAT 334

  16. Temperature object class temp { private float kelvin ; setCelsius( float C ); { if( C < -273.15 ) return ; // perhaps an error message would be in order else kelvin = C + 273.15 ; } float getCelsius() { return( kelvin - 273.15 ); } float setKelvin( float k ) { if( k < 0 ) return ; else kelvin = k ; } } IAT 334

  17. Temperature object • Controls access • Ensures correctness • can only run a setXYZ() to change temp • can only do getXYZ() to get the value in the desired scale • Who cares? IAT 334

  18. Who cares? • When you want to: • Solve the problem once and forget it • Reuse the solution elsewhere • Establish rules for use and change of data • The principle: • Information hiding • By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world. IAT 334

  19. Principle: Code re-use • If an object already exists, you can use that object in your program. • Specialists build, you use IAT 334

  20. Principle: Define the Interface • Define the interface: • The list of methods with Defined Operation • The interface is the thing that other people use • If you have the same interface with the same meaning • You can plug in a better implementation! IAT 334

  21. Define the Interface • If you have the same interface with the same meaning • You can plug in a better implementation! • You can plug in a More Interesting implementation! IAT 334

  22. Summary of principles • Hide unnecessary details • Clearly define the interface • Allow and support code re-use • Build on the work of others IAT 334

  23. Inheritance IAT 334

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

  25. 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 334

  26. 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 334

  27. 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 334

  28. 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 334

  29. 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 334

  30. 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 334

  31. Recap: Rocket • In Lab 2, we created the Rocket class • Constructor: Rocket(intinitialX, intinitialY, float initialRot ) • Methods draw() rotateClockwise() rotateCounterClockwise() fireThrusters() IAT 334

  32. Asteroids • Let’s adapt this to make an array of Asteroids for our rocket from Lab 2 class Asteroid { //fields float rotation = 0; float xPos, yPos; float velocityX, velocityY; long lastDrawMillis = 0; … } IAT 334

  33. 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 334

  34. Asteroids class Asteroid { … // draw method void draw () { IAT 334

  35. 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 334

  36. Inheritance • Subclasses inherit fields and methods from parent class ArmedRocket extends Rocket { … } IAT 334

  37. 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 334

  38. 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 334

  39. 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 334

  40. 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 334

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

  42. 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 334

  43. 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 334

  44. 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 334

  45. 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 334

  46. 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 334

  47. 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… ArrayListasteroids = new ArrayList(); for(inti = 0; i < numAsteroids; i++) asteroids.add(new Asteroid()); IAT 334

  48. 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 334

  49. 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 334

  50. 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 334