IAT 265
OO programming - Inheritance
______________________________________________________________________________________
SCHOOL OF INTERACTIVE ARTS + TECHNOLOGY [SIAT] | WWW.SIAT.SFU.CA
IAT 265
1
Outline
Object-oriented programming
– objects
– classes
• sets (mutators) and gets (accessors)
• object methods
– Inheritance: Subclasses
• Rocket, ArmedRocket
Collections
– ArrayList
June 9, 2015
IAT 265
2
Inheritance
June 9, 2015
IAT 265
3
Classes
Types
– Primitives: int, float, char, boolean …
– Objects: array, string, class …
June 9, 2015
IAT 265
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.
June 9, 2015
IAT 265
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)
}
June 9, 2015
IAT 265
Fields and Methods
class MySquare {
int xPos, yPos;
MySquare(x, y) {
xPos = x;
yPos = y;
}
fields
x
constructor
drawMe()
(one kind
of method)
void drawMe() {
rect(xPos, yPos, 50, 50);
}
methods
}
June 9, 2015
y
IAT 265
Fields and Methods
x
class MySquare {
int xPos, yPos;
y
drawMe()
MySquare(x, y) {
xPos = x;
yPos = y;
}
void drawMe() {
rect(xPos, yPos, 50, 50);
}
10 10
drawMe()
}
square1
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
June 9, 2015
IAT 265
20 90
drawMe()
square2
Fields and Methods
x
class MySquare {
int xPos, yPos;
drawMe()
MySquare(int x, int y) {
xPos = x;
yPos = y;
}
10 10
drawMe()
void drawMe() {
rect(xPos, yPos, 50, 50);
}
square1
}
MySquare square1 = new MySquare(10, 10);
MySquare square2 = new MySquare(20, 90);
square1.drawMe();
square2.drawMe();
June 9, 2015
y
IAT 265
20 90
drawMe()
square2
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();
June 9, 2015
// draw the 4th square.
IAT 265
Recap: Rocket
Earlier,
we created the Rocket class
– Constructor:
Rocket(int initialX, int initialY, float initialRot )
– Methods
draw()
rotateClockwise()
rotateCounterClockwise()
fireThrusters()
June 9, 2015
IAT 265
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;
…
}
June 9, 2015
IAT 265
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;
}
June 9, 2015
IAT 265
Asteroids
class Asteroid {
…
// draw method
void draw () {
June 9, 2015
IAT 265
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!
June 9, 2015
IAT 265
Inheritance
Subclasses
inherit fields and methods
from parent
class ArmedRocket extends Rocket
{
…
}
June 9, 2015
IAT 265
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
June 9, 2015
IAT 265
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
June 9, 2015
IAT 265
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?
June 9, 2015
IAT 265
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
June 9, 2015
IAT 265
The fire() method
Missile fire()
{
Missile m = new Missile(xPos, yPos,
rotation);
return m;
}
Now
June 9, 2015
add code in loop to draw missiles
IAT 265
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
June 9, 2015
IAT 265
22
The Java SDK
Java
comes with thousands of classes in
the Java Platform API
Documentation
website
Let’s
June 9, 2015
is available on Sun’s
look at ArrayList
IAT 265
23
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
June 9, 2015
IAT 265
24
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…
June 9, 2015
IAT 265
25
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()
June 9, 2015
IAT 265
26
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(int i = 0; i < numAsteroids; i++)
asteroids.add(new Asteroid());
June 9, 2015
IAT 265
27
Getting things out of an
ArrayList
i) – returns the
ith object (starting with 0)
ArrayList.get(int
But
this doesn’t work!
asteroids.get(i).draw();
Why?
June 9, 2015
IAT 265
28
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();
June 9, 2015
IAT 265
29
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;
}
June 9, 2015
IAT 265
30
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));
}
}
June 9, 2015
IAT 265
31
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
June 9, 2015
IAT 265
32
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)
June 9, 2015
IAT 265
33
0
