The Coder's Handbook

Inheritance

WHAT IS INHERITANCE?

Problem of Similar Classes


When you write a program, you will often find that you have many classes that share code because they're similar to one another. For example, in your Fireworks project - how often did you find yourself copy-pasting large chunks of code?


This is actually a big problem:

  • It's a pain to have to copy all that code

  • It looks really messy

  • When you change one class, you have to change all of them


Inheritance


To solve this problem, we'll use inheritance. This allows us to define one class - called a superclass - that shares all of its traits with a subclass.


They will automatically "inherit" the classes objects and methods. This means we won't need to define them in the subclass, and can even modify them!


Parent / Child


We also use the term parent class to refer to the superclass, and child class to refer to the subclass. You'll hear those terms used interchangeably; both are acceptable.

AN EXAMPLE

The Person Superclass


Let's consider that you might define a person class. Every object of class person has a set of traits that define it.


Every person has two piece of data and three methods:

  • String name

  • String designation

  • void learn()

  • void walk()

  • void eat()

The Programmer Subclass


To make a subclass, you'll use the keyword extends. For example, we might write:


public class Programmer extends Person


This means that a programmer "is-a" person. You can now create a Programmer object, and freely call any method defined in Person!


But a programmer isn't just a copy of its superclass. It has an additional piece of data and method, which we'd write the same way you would write it in a normal class.

  • String companyName

  • void coding()


This means that a programmer has all of the functionality of a Person, but only needs to add a small amount of code for its own special data and method!

OVERRIDING METHODS

Doing Things My Own Way


But wait, there's more! What if a programmer does something that a normal person does, but in a different way? You can override any method from the superclass, providing it new behavior.


class Person

{

public void eat()

{

System.out.println("Eats at a table like a normal human.");

}

}


class Programmer extends Person

{

public void eat()

{

System.out.println("Grabs snacks to fuel coding rampage.");

}

}


In this example, when you create a Programmer and call the eat() method, it will always use the behavior of the subclass.


Remember: the method from the superclass is only called if you do not provide a more specific implementation in the subclass!


No Jimothy! Do not ingest the computer.

USING SUPER

Like My Parent, But Different


Okay, but what if I mostly want to copy the behavior from my super class, but change it in a small way? Like, I do everything the superclass does... but I add a little something else?


To do so, you'll use the super keyword to call the parent's version of the method.


class Person

{

public void learn()

{

read();
practice();

application();

}

}


class Programmer extends Person

{

public void learn()

{

complain();

procrastinate();

super.learn();

}

}


In this example, a programmer will do all the steps needed to learn - but will also first complain and procrastinate. This allows you to avoid repeating code, but still make the subclass unique.


RESOURCES

Coding Train - Inheritance Part 1

Coding Train - Inheritance Part 2