Inheritance

What is Inheritance?

 In the real world: We inherit traits from our

mother and father. We also inherit traits from
our grandmother, grandfather, and ancestors.
We might have similar eyes, the same smile, a
different height . . . but we are in many ways
"derived" from our parents.

 In software: Object inheritance is more well

defined! Objects that are derived from other
object "resemble" their parents by inheriting
both state (fields) and behavior (methods).
Dog Class

public class Dog {

private String name;
private int fleas;

public Dog(String n, int f) {

name = n;
fleas = f;
}

public String getName() { return name; }

public int getFleas() { return fleas; }

public void speak() {

System.out.println("Woof");
}
}
Cat Class

public class Cat {

private String name;
private int hairballs;

public Cat(String n, int h) {

name = n;
hairballs = h;
}

public String getName() { return name; }

public int getHairballs() { return hairballs; }

public void speak() {

System.out.println("Meow");
}
}
Problem: Code Duplication

• Dog and Cat have the name field and the getName
method in common

●
Classes often have a lot of state and behavior in
common

●
Result: lots of duplicate code!
Solution: Inheritance

●
Inheritance allows you to write new classes
that inherit from existing classes

●
The existing class whose properties are
inherited is called the "parent" or
superclass

●
The new class that inherits from the super
class is called the "child" or subclass

●
Result: Lots of code reuse!
 Dog Cat
String name String name
int fleas int hairballs
String getName() String getName()
int getFleas() int getHairballs()
void speak() void speak()

using
inheritance

superclass
Animal
subclass
String name
subclass String getName()

Dog Cat
int fleas int hairballs
int getFleas() int getHairballs()
void speak() void speak()
Animal Superclass

public class Animal {

private String name;

public Animal(String n) {
name = n;
}

public String getName() {

return name;
}
}
Dog Subclass

public class Dog extends Animal {

private int fleas;

public Dog(String n, int f) {

super(n); // calls Animal constructor
fleas = f;
}

public int getFleas() {

return fleas;
}

public void speak() {

return System.out.println("Woof");
}
}
Cat Subclass

public class Cat extends Animal {

private int hairballs;

public Cat(String n, int h) {

super(n); // calls Animal constructor
hairballs = h;
}

public int getHairballs() {

return hairballs;
}

public void speak() {

return System.out.println("Meow");
}
}
Inheritance Quiz 1

●
What is the output of the following?

Dog d = new Dog("Rover" 3);

Cat c = new Cat("Kitty", 2);
System.out.println(d.getName() + " has " +
d.getFleas() + " fleas");
System.out.println(c.getName() + " has " +
c.getHairballs() + " hairballs");

Rover has 3 fleas

Kitty has 2 hairballs

(Dog and Cat inherit the getName method from

Animal)
Inheritance Rules

● Use the extends keyword to indicate that

one class inherits from another

●
The subclass inherits all the fields and
methods of the superclass

● Use the super keyword in the subclass

constructor to call the superclass
constructor
Subclass Constructor

●
The first thing a subclass constructor must do
is call the superclass constructor

●
This ensures that the superclass part of the
object is constructed before the subclass part

●
If you do not call the superclass constructor
with the super keyword, and the superclass
has a constructor with no arguments, then
that superclass constructor will be called
implicitly.
 Implicit Super Constructor Call

then this Beef subclass:

public class Beef extends Food {

If I have this Food class: private double weight;
public Beef(double w) {
public class Food { weight = w
private boolean raw; }
public Food() { }
raw = true;
} is equivalent to:
}
public class Beef extends Food {
private double weight;
public Beef(double w) {
super();
weight = w
}
}
Inheritance Quiz 2

public class A {
public A() { System.out.println("I'm A"); }
}

public class B extends A {

public B() { System.out.println("I'm B"); }
}

public class C extends B {

public C() { System.out.println("I'm C"); }
}

What does this print out? I'm A

I'm B
C x = new C(); I'm C
Overriding Methods

• Subclasses can override methods in their superclass

class Therm { class ThermUS extends Therm {
public double celsius;
public ThermUS(double c) {
public Therm(double c) { super(c);
celsius = c; }
}
// degrees in Fahrenheit
public double getTemp() { public double getTemp() {
return celcius; return celsius * 1.8 + 32;
} }
} }

• What is the output of the following? 212

ThermUS thermometer = new ThermUS(100);
System.out.println(thermometer.getTemp());
 Calling Superclass Methods

●
When you override a method, you can
call the superclass's copy of the method
by using the syntax super.method()

class Therm { class ThermUS extends Therm {

private double celsius;
public ThermUS(double c) {
public Therm(double c) { super(c);
celcius = c; }
}
public double getTemp() {
public double getTemp() { return super.getTemp()
return celcius; * 1.8 + 32;
} }
} }
Access Level

• Classes can contain fields and methods

of four different access levels:
• private: access only to the class itself

• package: access only to classes in the

same package

• protected: access to classes in the

same package and to all subclasses

• public: access to all classes everywhere

Variable Type vs Object Type

●
Variables have the types they are given
when they are declared and objects have
the type of their class.
●
For an object to be assigned to a variable
is must be of the same class or a
subclass of the type of the variable.
●
You may not call a method on a variable
if it's type does not have that method,
even if the object it references has the
method.
 Which Lines Don't Compile?

public static void main(String[] args) {

Animal a1 = new Animal();
a1.getName();
a1.getFleas(); // Animal does not have getFleas
a1.getHairballs(); // Animal does not have getHairballs
a1.speak(); // Animal does not have speak
Animal a2 = new Dog();
a2.getName();
// Animal does not have getFleas
a2.getFleas();
// Animal does not have getHairballs
a2.getHairballs(); // Animal does not have speak
a2.speak();
Dog d = new Dog();
d.getName();
d.getFleas(); // Dog does not have getHairballs
d.getHairballs();
d.speak();
}
Remember Casting?

●
"Casting" means "promising" the compiler
that the object will be of a particular type

●
You can cast a variable to the type of the
object that it references to use that
object's methods without the compiler
complaining.

●
The cast will fail if the variable doesn't
reference an object of that type.
 Which Castings Will Fail?

public static void main(String[] args) {

Animal a1 = new Animal();
((Dog)a1).getFleas(); // a1 is not a Dog
((Cat)a1).getHairballs(); // a1 is not a Cat
((Dog)a1).speak(); // a1 is not a Dog

Animal a2 = new Dog();

((Dog)a2).getFleas();
((Cat)a2).getHairballs(); // a2 is not a Cat
((Dog)a2).speak();

Dog d = new Dog(); // d is not a Cat

((Cat)d).getHairballs();
}
 Programming Example

●
A Company has a list of Employees. It asks you
to provide a payroll sheet for all employees.
– Has extensive data (name, department, pay amount, …) for
all employees.
– Different types of employees – manager, engineer,
software engineer.
– You have an old Employee class but need to add very
different data and methods for managers and
engineers.
●
Suppose someone wrote a name system, and already
provided a legacy Employee class. The old Employee class
had a printData() method for each Employee that only printed
the name. We want to reuse it, and print pay info.

Borrowed with permission from Course 1.00 Note

 REVIEW PICTURE
Encapsulation Message passing "Main event loop"

Employee e1 public … Main(…){

printData Employee e1…("Mary","Wang");
...
private:
e1.printData();
lastName
// Prints Employee names.
firstName
...
}
 Employee class
This is a simple super or base class.
class Employee {
// Data
private String firstName, lastName;

// Constructor
public Employee(String fName, String lName) {
firstName= fName; lastName= lName;
}
// Method
public void printData() {
System.out.println(firstName + " " + lastName);}
}
 Inheritance

Already written:
Class Employee

firstName printData()
lastName

is-a is-a

Class Engineer
Class Manager

firstName firstName
lastName lastName
hoursWorked
salary wages
printData()
getPay()
printData()
getPay()
You next write:
 Engineer class
Subclass or (directly) derived class
class Engineer extends Employee {
private double wage;
private double hoursWorked;
public Engineer(String fName, String lName,
double rate, double hours) {
super(fName, lName);
wage = rate;
hoursWorked = hours;
}

public double getPay() {

return wage * hoursWorked;
}

public void printData() {

super.printData(); // PRINT NAME
System.out.println("Weekly pay: $" + getPay(); }
 Manager class
Subclass or (directly) derived class
class Manager extends Employee {
private double salary;

public Manager(String fName, String lName, double sal){

super(fName, lName);
salary = sal; }

public double getPay() {

return salary; }

public void printData() {

super.printData();
System.out.println("Monthly salary: $" + salary);}
}
 Inheritance…

Class Manager

firstName
lastName

Salary
is-a
printData
getPay
Class SalesManager

firstName
lastName

Salary
printData
getPay salesBonus
 SalesManager Class
(Derived class from derived class)
class SalesManager extends Manager {
private double bonus; // Bonus Possible as commission.

// A SalesManager gets a constant salary of $1250.0

public SalesManager(String fName, String lName, double b) {
super(fName, lName, 1250.0);
bonus = b; }

public double getPay() {

return 1250.0; }

public void printData() {

super.printData();
System.out.println("Bonus Pay: $" + bonus; }
}
 Main method

public class PayRoll {

public static void main(String[] args) {
// Could get Data from tables in a Database.
Engineer fred = new Engineer("Fred", "Smith", 12.0, 8.0);
Manager ann = new Manager("Ann", "Brown", 1500.0);
SalesManager mary= new SalesManager("Mary", "Kate", 2000.0);

// Polymorphism, or late binding

Employee[] employees = new Employee[3];
employees[0]= fred;
employees[1]= ann;
employees[2]= mary; Java knows the
for (int i=0; i < 3; i++)
object type and
employees[i].printData();
} chooses the
} appropriate method
at run time
 Output from main method

Fred Smith
Weekly pay: $96.0
Ann Brown
Monthly salary: $1500.0
Mary Barrett
Monthly salary: $1250.0
Bonus: $2000.0

Note that we could not write:

employees[i].getPay();
because getPay() is not a method of the superclass Employee.

In contrast, printData() is a method of Employee, so Java can find the

appropriate version.
Object Class

●
All Java classes implicitly inherit from
java.lang.Object

●
So every class you write will automatically have
methods in Object such as equals, hashCode, and
toString.

●
We'll learn about the importance of some of these
methods in later lectures.