Goals

• Inheritance
  • How / Why / When to extend a class
  • What's in a subclass
  • Using Super
• Using Subclasses
  • Polymorphism
  • Overriding

Resources

http://processing.org/learning/basics/inheritance.html
http://processing.org/learning/topics/multipleparticlesystems.html

How to Extend a Class

Extending a class is simple. In a new class definition, simply add the word extends and the name of the class the new class should extend. This new class is now a subclass of the class which it extends.

class RaceBike extends Bicycle { //The RaceBike constructor RaceBike() { println("Hi I'm a RaceBike object"); } }

Why Extend a Class

In processing and other programming languages there are various tools to help add complexity to a program without requiring the programmer to rewrite a lot of code. In fact, good programming practice should have you never writing the same code twice. Since we are working with objects, sometimes it's beneficial to describe objects as more specific versions of some general object.

Take a look at these bikes. There is a general Bicycle object, and then there are a few specific Bicycle objects. Each specific Bicycle object extends the general Bicycle class, and therefore is a subclass of the Bicycle class.

When to Extend a Class (Abstraction)

As mentioned previously, the goal of efficient programming is to never repeat yourself. If we find that when creating a new object we're repeating a lot of the fields and methods that belong to another, similar object. We might want to "abstract" out the common properties of both classes, and put these into a parent class. Now each object from before can inherit these common fields and methods, and there's no need to code them for each object.

Take another look at the bikes. Every bicycle needs a position, wheel rotation, gear, etc...
But only a mountain bike would need shock suspension. And perhaps only a race bike would need road tires, or a spedometer.
When designing several classes, always remember that common fields and methods should be combined into a parent class, and each class should extend from that parent. This will save time and create cleaner, more flexible code.

Subclasses

A subclass is simply a class which extends another class. This is called inheritance because the sublclass inherits the fields and methods of the parent class. Let's take a look at the anatomy of a subclass:

class Bicycle { float xPos, yPos, xVel, yVel; Bicycle() { ... } //A simple constructor void move() { ... } //A move method ... } class RaceBike extends Bicycle { //RaceBike inherits xPos, yPos, xVel, yVel //We only declare are fields unique to RaceBike int spedometer; //Every class needs a unique constructor RaceBike() { ... } //RaceBike inherits the move method //All we have to code are methods unique to RaceBike void updateSpedometer() { ... } ... }

Notice how our subclass RaceBike inherits the fields and methods of Bicycle? This means that each new RaceBike object can set the values of xPos, yPos, xVel, yVel, in addition to the new field spedometer (specific to the RaceBike class).

Let's take a look at how we could create an instance of the RaceBike class and use some inherited fields and methods from the Bicycle class:

RaceBike myBike = new RaceBike(); myBike.xPos = width/2; //belongs to all Bicycle objects myBike.yPos = height/2; myBike.xVel = 1; myBike.move(); //belongs to all Bicycle objects myBike.updateSpedometer(); //unique to RaceBike objects

Super

Super is a special scoped reference variable which can be used to the set the scope to the parent class. Scope is what is visible or accessible by processing. This means we can use super to transition from the scope of our subclass to the scope of the parent class. Let's take a look at how we can use super:

The super( ... ) Constructor

Sometimes it may be advantageous for a subclass to call the constructor of it's parent class. We can achieve this by using the super( ... ) constructor. Here's an example:

class Bicycle { float xPos, yPos, xVel, yVel; Bicycle() { xPos = random(width); yPos = random(height); } //an overloaded constructor Bicycle(int startX, int startY) { xPos = startX; yPos = startY; } ... } class RaceBike extends Bicycle { int spedometer; RaceBike() { super(); //call Bicycle constructor spedometer = 0; } RaceBike(int startX, int startY) { //call overloaded Bicycle constructor super(startX, startY); spedometer = 0; } ... }

Notice when using super( ... ) we must pass in parameters to match the constructor we are calling. There are two constructors here: one to initialize the bike with a random position, and the other (overloaded) one to initialize it with a specific position. By using super( ... ) with appropriate arguments for each constructor in the subclass RaceBike, we've managed to match parameters and leverage the code that was already written in the Bicycle class constructors.

The super Reference Variable

We can also use super as a special reference variable to call methods of a parent class from within the subclass. Here's an example:

class Bicycle { ... void move() { ... } void changeGear(int gear) { ... } ... } class RaceBike extends Bicycle { ... void race() { super.move(); if (speed < 4) { super.changeGear(gear - 1); } } ... }

Polymorphism

Remember how a subclass inherits all of the fields and methods of a parent class? This means that processing now considers the subclass to be an equivalent of the parent class. This principle is called polymorphism and we usually say that an instance of a subclass "is a" instance of the parent class.
In other words: a RaceBike "is a" Bicycle.
Let's see this in action:

//Same reference type as the object instance RaceBike myBike = new RaceBike(); //Using the parent type to store a subclass reference Bicycle myBike2 = new RaceBike();

Storing a subclass reference using the parent class type is totally legal, however the reverse is not possible. Since a RaceBike "is a" Bicycle, we can use a Bicycle reference variable to store a RaceBike reference, but a Bicycle is not necessarily a RaceBike.

Advantages

Polymorphism has it's advantages, since all Bicycle subclasses can be treated as if they were Bicycles. For instance we can take all Bicycle instances, regardless of type, and store them in a single typed ArrayList since they are all Bicycles.

Disadvantages

There is a disadvantage to using the parent type to store a reference of a subclass. The reference variable type is of the parent class, therefore we cannot use this variable to access the fields or methods of the subclass. Let's see an example:

//Same reference type as the object instance RaceBike myBike = new RaceBike(); //Using the parent type to store a subclass reference Bicycle myBike2 = new RaceBike(); myBike.xPos = width/2; //works myBike2.xPos = width/2; //works myBike.updateSpedometer(); //works myBike2.updateSpedometer(); //fails (myBike2 is type Bicycle)

Overriding

Overriding is similar to overloading, however it involves a subclass implementing a method with the exact same method signature as the parent class. If an instance of the subclass is stored in a reference variable of the parent type, the overridden methods of the subclass will be called instead of the parent's methods. By overriding methods properly we can treat all objects as the parent type, call the same methods, while having different implementations. Here is an example:

class Bicycle { ... void move() { ... } void changeGear(int gear) { ... } ... } class RaceBike extends Bicycle { ... void move() { RaceBike move method } void changeGear(int gear) { RaceBike changeGear method } ... }

Notice how the RaceBike methods have the same method signature as the Bicycle methods. Even if a RaceBike is stored in a reference variable of type Bicycle, when we call the methods of this variable we will in fact be calling the overridden methods from the RaceBike class.

ArrayList<Ball> ballList = new ArrayList<Ball>(); void setup() { size(400, 400); stroke(0, 128); strokeWeight(2); fill(255, 0, 0, 128); //The ArrayList doesn't have a size yet //So we have to set how much we will loop literally (10) for (int i = 0; i < 50; i++) { //Every odd ball will be a crazy ball object if (i % 2 == 0) { ballList.add(new Ball()); } else { ballList.add(new CrazyBall()); } } } void draw() { background(255); //Now that the ArrayList has a size we can use .size() //in our loop for (int i = 0; i < ballList.size(); i++) { //Get the current ball in the loop, the ball at position i //Notice we DON'T have to cast the reference variable //since the ArrayList is typed Ball curBall = ballList.get(i); curBall.update(); curBall.checkWalls(); curBall.drawMe(); } } //A crazy ball object class CrazyBall extends Ball { //inherited fields: xPos, yPos, xVel, yVel float mass; CrazyBall() { super(); //call Ball constructor mass = random(1,4); } //override the update method from Ball class void update() { //add an attraction to the mouse position xVel += (mouseX - xPos)/width * 1/mass; yVel += (mouseY - yPos)/height * 1/mass; //dampen the velocity xVel *= 0.98; yVel *= 0.98; //call the ball update method to update position super.update(); } } //A class to describe a ball object class Ball { float xPos, yPos, xVel, yVel; Ball() { //Set the initial values for our Ball object's variables (fields) xPos = random(16, width - 16); yPos = random(16, height - 16); xVel = random(-2, 2); yVel = random(-2, 2); } //A method to update the ball position void update() { xPos += xVel; yPos += yVel; } //A method to check collisions with the walls void checkWalls() { if (abs(xPos - width/2) > 200 - 16) { xVel *= -1; } if (abs(yPos - height/2) > 200 - 16) { yVel *= -1; } } //A method to draw the ball object void drawMe() { pushMatrix(); translate(xPos, yPos); ellipse(0, 0, 32, 32); popMatrix(); } }