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