Inheritance

© 2017 Wipro wipro.com confidential 1

Agenda

Inheritance

Multilevel Hierarchy

© 2017 Wipro wipro.com confidential 2

Objectives
At the end of this module, you will be able to:
 Describe Java’s inheritance model and its language syntax
 Describe the usage of the keyword super
 Define a multilevel hierarchy
 Describe method overriding
 Describe dynamic method dispatch, or runtime polymorphism
 Understand the use of instanceof operator
 Get basic information about garbage collection
 Define finalize method

© 2017 Wipro wipro.com confidential 3

Inheritance

© 2017 Wipro wipro.com confidential 4

Inheritance in real world

Have you seen some people who

have BLUE EYES?

Some people have BLUE EYE:

How it is possible?

Some people have BROWN EYE:

How it is possible?

Some people have GREEN EYE:

How it is possible?

© 2017 Wipro wipro.com confidential 5

Inheritance in real world (Contd.).
In real life, what is meant by
inheritance?

What you inherit from your parent?

What is your own behavior which is
not found in your parent?

Child inherits some properties from its

parent. Apart from that, child has its
own properties….

© 2017 Wipro wipro.com confidential 6

Inheritance
 Inheritance is one of the cornerstones of OOP because it allows for the creation of
hierarchical classifications

 Using inheritance, you can create a general class at the top

 This class may then be inherited by other, more specific classes

 Each of these classes will add only those attributes and behaviors that are unique to it

© 2017 Wipro wipro.com confidential 7

Generalization/ Specialization
 In keeping with Java terminology, a class that is inherited is referred to as a superclass

 The class that does the inheriting is referred to as the subclass

 Each instance of a subclass includes all the members of the superclass

 The subclass inherits all the properties of its superclass

© 2017 Wipro wipro.com confidential 8

Association, Aggregation, Composition
 These terms are used to signify the relationship between classes
 They are the basic building blocks of OOPS

© 2017 Wipro wipro.com confidential 9

Association
 Association is a relationship between two objects
 The association between objects could be
 one-to-one
 one-to-many
 many-to-one
 many-to-many
 Types of Association
 Aggregation
 Composition

 Example: A Student and a Faculty are having an association

© 2017 Wipro wipro.com confidential 10

Aggregation
 Aggregation is a special case of association

 A directional association between objects

 When an object ‘has-a’ another object, then you have got an aggregation between them

 Aggregation is also called a “Has-a” relationship.

 Example: College has a Student Object

© 2017 Wipro wipro.com confidential 11

Composition

• Composition is a special case of aggregation

• In a more specific manner, a restricted aggregation is called composition

• When an object contains the other object, if the contained object cannot exist without the
existence of container object, then it is called composition

• Example: A class contains students. A student cannot exist without a class. There exists
composition between class and students

© 2017 Wipro wipro.com confidential 12

IS-A relationship: Manager IS-A Employee

4 Employees of a department

Their Manager

© 2017 Wipro wipro.com confidential 13

HAS-A relationship
 HAS-A relationship is expressed with containership
 Containership simply means using instance variables that refer to other objects
 Example:
 The class House will have an instance variable which refers to a Kitchen object
 It means that, House HAS-A Kitchen
 Note that, something like Kitchen HAS-A House is not valid in this context

© 2017 Wipro wipro.com confidential 14

HAS-A relationship (Contd.).
 Let us take one personal computer.
 It has a monitor, CPUbox, keyboard and mouse, etc.
 Technically we can say that,
 Personal Computer class HAS-A monitor.
 Personal Computer class HAS-A CPUbox
 Personal Computer class HAS-A keyboard.
 Personal Computer class HAS-A mouse.
 The most important point is : the 4 independent components like monitor, keyboard,
CPUbox and mouse cannot function separately on its own.
 But, by combining them, we are creating a new type of useful class called Personal
Computer.

© 2017 Wipro wipro.com confidential 15

Java’s Inheritance Model
 Java uses the single inheritance model
 In single inheritance, a subclass can inherit from one (and only one) superclass

Code Syntax for Inheritance:

class derived-class-name extends base-class-name
{
// code goes here
}

© 2017 Wipro wipro.com confidential 16

Inheritance – A Simple Example
class A{
int m, n;
void display1( ){
System.out.println("m and n are:"+m+" "+n);
}
}
class B extends A{
int c;
void display2( ){
System.out.println("c :" + c);
}
void sum(){
System.out.println("m+n+c = " + (m+n+c));
}
} © 2017 Wipro wipro.com confidential 17
Inheritance – A Simple Example (Contd.).
class InheritanceDemo{
public static void main(String args[ ]){

A s1 = new A(); // creating objects

B s2 = new B();
s1.m = 10; s1.n = 20;

System.out.println("State of object A:");

s1.display1();
s2.m = 7; s2.n = 8; s2.c = 9;
System.out.println("State of object B:");
s2.display1();
s2.display2();
System.out.println("sum of m, n and c in object B is:");
s2.sum();
}
} © 2017 Wipro wipro.com confidential 18
Accessing Superclass Members from a Subclass Object
 A subclass includes all of the members of its superclass

 But, it cannot directly access those members of the super class that have been declared as
private.

class A{
int money;
private int pocketMoney;

void fill (int money, int pocketMoney)

{
this.money = money;
this.pocketMoney = pocketMoney;
}
}

© 2017 Wipro wipro.com confidential 19

Accessing Superclass Members from a Subclass Object
(Contd.).
class B extends A{ Will this compile now?
int total;
void sum( ){
total = money + pocketMoney;
} }
class AccessDemo
{
public static void main(String args[ ])
{
B subob = new B();
subob.fill(10,12);
subob.sum();
System.out.println("Total: " + subob.total);
}
} © 2017 Wipro wipro.com confidential 20
A Possible Solution To The Program
class A{
int money;
private int pocketMoney;
void fill(int money, int pocketMoney)
{
this.money = money;
this.pocketMoney = pocketMoney;
}
public int getPocketMoney(){
return pocketMoney;
}
}

© 2017 Wipro wipro.com confidential 21

A Possible Solution To The Program (Contd.).
class B extends A{
Will this compile now?
int total;
void sum( ) {
total = money + getPocketMoney(); }
}
class AccessDemo {
public static void main(String args[ ]) {
B subob = new B();
subob.fill(10,12);
subob.sum();
System.out.println("Total: " + subob.total);
}
}
© 2017 Wipro wipro.com confidential 22
Using super
 The creation and initialization of the superclass object is a prerequisite to the creation of the
subclass object.
 When a subclass object is created,
 It creates the superclass object

 Invokes the relevant superclass constructor.

– The initialized superclass attributes are then inherited by the subclass object

 finally followed by the creation of the subclass object

– initialization of its own attributes through a relevant constructor subclass

© 2017 Wipro wipro.com confidential 23

Using super (Contd.).

 The constructors of the superclass are never inherited by the subclass

 This is the only exception to the rule that a subclass inherits all the properties of its
superclass

© 2017 Wipro wipro.com confidential 24

A Practical Example
package mypack; Employee class should be put
class Employee { inside the mypack directory..
int Employeeno; String Empname;
Employee() {
System.out.println(" Employee No-arg Constructor Begins");
Employeeno =0; Empname= null ;
// the above assignments are unnecessary .. Why?
System.out.println(" Employee No-arg Constructor Ends");
}
Employee(int Employeeno) {
System.out.println(" Employee 1-arg Constructor Begins");
this.Employeeno=Employeeno;
this.Empname= "UNKNOWN";
System.out.println(" Employee 1-arg Constructor Ends");
} © 2017 Wipro wipro.com confidential 25
A Practical Example (Contd.).
Employee(int Employeeno, String s) {
System.out.println(" Employee 2-arg Constructor Begins");
this.Employeeno = Employeeno;
this.Empname = s;
System.out.println(" Employee 2-arg Constructor Ends");
}
void display() {
System.out.println(" Employee Number = "+Employeeno);
System.out.println(" Employee Name = "+Empname);
}

} // End of the Employee class

© 2017 Wipro wipro.com confidential 26

A Practical Example (Contd.).
class Manager extends Employee
{
String deptname;
Manager(int Employeeno, String name, String deptname )
{
super(Employeeno, name);
// parent class 2-arg constructor is called

System.out.println(" Manager 3-arg Constructor Begins");

this.deptname = deptname;
System.out.println(" Manager 3-arg Constructor Ends");
}

© 2017 Wipro wipro.com confidential 27

A Practical Example (Contd.).
void display() {
super.display();
// parent class display() function is called
System.out.println(" Deptname = "+deptname);
}
public static void main( String a[]) {
System.out.println(" [Main function Begins----------------------] ");
System.out.println(" Creating an object for manager class ");
Manager mm = new Manager(10,"Gandhi","Banking");
System.out.println(" Printint the manager details .... : ");
mm.display();
System.out.println(" [Main function Ends----------------------] ");
}
}

© 2017 Wipro wipro.com confidential 28

Using super to Call Superclass Constructors
 super() if present, must always be the first statement executed inside a subclass constructor.

 It clearly tells you the order of invocation of constructors in a class hierarchy.

 Constructors are invoked in the order of their derivation

© 2017 Wipro wipro.com confidential 29

Constructors – Order of Invocation
Constructors in a class hierarchy are invoked in the order of their derivation.

class X {
X( ){
System.out.println(“Inside X’s Constructor”); } }

class Y extends X {
Y( ) {
System.out.println(“Inside Y’s Constructor”); } }

class Z extends Y {
Z(){
System.out.println(“Inside Z’s Constructor”); } }

class OrderOfConstructorCallDemo{
public static void main(String args[]){
You can easily find the output of
Z z = new Z(); this program..
}
}
© 2017 Wipro wipro.com confidential 30
Constructors – Order of Invocation (Contd.).
 When we invoke a super() statement from within a subclass constructor, we are invoking the
immediate super class’ constructor

 This holds good even in a multi level hierarchy

 Remember, super( ) can only be given as the first statement within a constructor

© 2017 Wipro wipro.com confidential 31

Using this() in a constructor
 this(argument list) statement invokes the constructor of the same class

 first line of a constructor must EITHER be a super (call on the super class constructor)
OR a this (call on the constructor of same class)

 If the first statement within a constructor is NEITHER super() NOR this(), then the
compiler will automatically insert a super(). (That is, invocation to the super class’ no
argument constructor)

© 2017 Wipro wipro.com confidential 32

QUIZ
What is the result, if we try to compile & execute the following code:

class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println(“B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){ The participants are expected to
C1 ca = new C1(); answer this question during session
}
}
© 2017 Wipro wipro.com confidential 33
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println(“B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{ The participants are expected to
public static void main(String args[]){
C1 ca = new C1(10); answer this question during
} session
}
© 2017 Wipro wipro.com confidential 34
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println(“B1‘s constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10); The participants are expected to
}
}
answer this question during session
© 2017 Wipro wipro.com confidential 35
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ System.out.println(“B1‘s constructor "+ b); }
}
class C1 extends B1{
C1() { super(100);
System.out.println(“C1's no arg constructor"); }
C1(int c){ System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10); The participants are expected to
} answer this question during session
}
© 2017 Wipro wipro.com confidential 36
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ super(50);
System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println(“B1‘s constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10); The participants are expected to answer
} this question during session
} © 2017 Wipro wipro.com confidential 37
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(String x){ super(50);
System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println(“B1‘s constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10); The participants are expected to
} answer this question during session
}
© 2017 Wipro wipro.com confidential 38
QUIZ(Contd.).
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println(“A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ this("x");
System.out.println(“B1's constructor "+ b); }
B1(String b){ super(1000);
System.out.println(“B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println(“C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println(“C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10);
} The participants are expected to answer
} this question during session
© 2017 Wipro wipro.com confidential 39
Multilevel Hierarchy

© 2017 Wipro wipro.com confidential 40

Defining a Multilevel Hierarchy
 Java allows us to define multiple layers in an inheritance hierarchy

 We can define a superclass and a subclass, with the subclass in turn becoming a superclass
for another subclass

 Consider the following example…

Draw the inheritance tree for this
• Employee example..
• Manager is a Employee
• Director is a Manager

 This is an example for multilevel inheritance

© 2017 Wipro wipro.com confidential 41

Defining a Multilevel Hierarchy (Contd.).
class Employee extends Object { }
class Manager extends Employee { }
class Director extends Manager { }
public class Test_Multi_Level_Inheritance
{
public static void salary(Object obj)
{
// Here, Object obj will accept the following:
// Object class objects
// Employee class objects
// Manager class objects
// Director class objects

© 2017 Wipro wipro.com confidential 42

Defining a Multilevel Hierarchy (Contd.).
// The following block decides what type of object is passed to this function.
// We test whether the object obj is really an instance of Director class or Manager class
or Employee class.
if (obj instanceof Director)
System.out.println (" Director Salary 30000$");
else if (obj instanceof Manager)
System.out.println (" Manager Salary 20000$");
else if (obj instanceof Employee)
System.out.println (" Employee Salary 10000$");
else System.out.println(" INVALID");
}
What will happen,
if it is tested like this ?:
First Employee,
then Manager,
then Director.

© 2017 Wipro wipro.com confidential 43

Defining a Multilevel Hierarchy (Contd.).
public static void main(String ss[])
{
System.out.println(“ Employee object e is created ");
Employee e = new Employee();
System.out.println(" Manager object m is created ");
Manager m = new Manager();
System.out.println(" Director object d is created ");
Director d = new Director();

© 2017 Wipro wipro.com confidential 44

Defining a Multilevel Hierarchy (Contd.).

System.out.println(" salary(e) is called ; ");

salary(e);
System.out.println(" salary(m) is called ; ");
salary(m);
System.out.println(" salary(d) is called ; ");
salary(d);
} // end of main
} // end of class What is the output?

© 2017 Wipro wipro.com confidential 45

Summary
 In this session, you were able to:
 Describe Java’s inheritance model and its language syntax

 Describe the usage of the keyword super

 Define a multilevel hierarchy

© 2017 Wipro wipro.com confidential 46

Thank You

© 2017 Wipro wipro.com confidential 47