Unit 4

UNIT-4
Inheritance and Interfaces
Use of Inheritance, Inheriting Data members and

Methods:
Basics of Inheritance:
1. Inheritance is one of the cornerstones of object-oriented programming because
it allows the creation of hierarchical classifications.
2. Using inheritance, you can create a general class that defines traits common
to a set of related items. This class can then be inherited by other, more
specific classes, each adding those things that are unique to it.
3.In the terminology of Java, a class that is inherited is called a superclass.

The class that does the inheriting is called a subclass. Therefore, a subclass
is a specialized version of a superclass. It inherits all of the instance
variables and methods defined by the superclass and adds its own, unique
elements.
Important terminology:
 Super Class: The class whose features are inherited is known as super
class(or a base class or a paren class).
 Sub Class: The class that inherits the other class is known as sub
class(or a derived class, extended class, or child class). The subclass
can add its own fields and methods in addition to the superclass fields
and methods.
 Reusability: Inheritance supports the concept of “reusability”, i.e. when
we want to create a new class and there is already a class that includes
some of the code that we want, we can derive our new class from the
existing class. By doing this, we are reusing the fields and methods of
the existing class.
To inherit a class, you simply incorporate the definition of one class into
another by using the extends keyword. To see how, let’s begin with a short
example. The following program creates a superclass called A and a subclass
called B. Notice how the keyword extends is used to create a subclass of A.
Inheritance Example
Let’s consider a superclass Vehicle. Different vehicles have different features
and properties however there few of them are common to all. Speed, color, fuel
used, size are few which are common to all. Hence we can create a class
‘Vehicle’ with states and actions that are common to all vehicles. The subclass
of this superclass can be any type of vehicle. Example: Class Car A has all the
features of a vehicle. But it has its own attributes which makes it different
from other subclasses. By using inheritance we need not rewrite the code that
we’ve already used with the Vehicle. The subclass can also be extended. We can
make a class ‘Sports Car’ which extends ‘Car’. It inherits the features of both
Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

‘Vehicle’ and ‘Car’.
The keyword used for inheritance is extends. Syntax:
public class ChildClass extends BaseClass {

// derived class methods extend and possibly override
}
Here is the complete example:
// A class to display the attributes of the vehicle

class Vehicle {
String color;
int speed;
int size;
void attributes() {
System.out.println("Color : " + color);
System.out.println("Speed : " + speed);
System.out.println("Size : " + size);
}
}
// A subclass which extends for vehicle

class Car extends Vehicle {
int CC;
int gears;
void attributescar() {
// The subclass refers to the members of the superclass
System.out.println("Color of Car : " + color);
System.out.println("Speed of Car : " + speed);
System.out.println("Size of Car : " + size);
System.out.println("CC of Car : " + CC);
System.out.println("No of gears of Car : " + gears);
}
}
public class Test {
public static void main(String args[]) {
Car b1 = new Car();
b1.color = "Blue";
b1.speed = 200 ;
b1.size = 22;
b1.CC = 1000;
b1.gears = 5;
b1.attributescar();
}
}
The output is
Color of Car : Blue

Speed of Car : 200
Size of Car : 22
CC of Car : 1000
No of gears of Car : 5
Note:
The derived class inherits all the members and methods that are declared as
public or protected. If declared as private it can not be inherited by the
derived classes. The private members can be accessed only in its own class. The

private members can be accessed through assessor methods as shown in the example
below. The derived class cannot inherit a member of the base class if the
derived class declares another member with the same name.
// A class to display the attributes of the vehicle

class Vehicle {
String color;
private int speed;
private int size;
public int getSize() {
return size;
}
public int getSpeed() {
return speed;
}
public void setSize(int i) {
size = i;
}
public void setSpeed(int i) {
speed = i;
}
}
// A subclass which extends for vehicle

class Car extends Vehicle {
int CC;
int gears;
int color;
void attributescar() {
// Error due to access violation
// System.out.println("Speed of Car : " + speed);
// Error due to access violation
//System.out.println("Size of Car : " + size);
}
}
public class Test {
Car b1 = new Car();
// the subclass can inherit 'color' member of the superclass
b1.color = 500;
b1.setSpeed(200) ;
b1.setSize(22);
b1.CC = 1000;
b1.gears = 5;
// The subclass refers to the members of the superclass
System.out.println("Color of Car : " + b1.color);
System.out.println("Speed of Car : " + b1.getSpeed());
System.out.println("Size of Car : " + b1.getSize());
System.out.println("CC of Car : " + b1.CC);
System.out.println("No of gears of Car : " + b1.gears);
}
}
The output is:
Color of Car : 500

Speed of Car : 200
Size of Car : 22
CC of Car : 1000
No of gears of Car : 5

Types of Inheritance :
1) Single Inheritance
Single inheritance is damn easy to understand. When a class extends another one
class only then we call it a single inheritance. The below flow diagram shows
that class B extends only one class which is A. Here A is a parent class of B
and B would be a child class of A.
Single Inheritance example program in Java
Class A
{
public void methodA()
{
System.out.println("Base class method");
}
}
Class B extends A
{
public void methodB()
{
System.out.println("Child class method");
}
public static void main(String args[])
{
B obj = new B();
obj.methodA(); //calling super class method
obj.methodB(); //calling local method
}
}
2) Multiple Inheritance
“Multiple Inheritance” refers to the concept of one class extending (Or
inherits) more than one base class. The inheritance we learnt earlier had the
concept of one base class or parent. The problem with “multiple inheritance” is
that the derived class will have to manage the dependency on two base classes.

Note 1: Multiple Inheritance is very rarely used in software projects. Using
Multiple inheritance often leads to problems in the hierarchy. This results in
unwanted complexity when further extending the class.
Note 2: Most of the new OO languages like Small Talk, Java, C# do not support
Multiple inheritance. Multiple Inheritance is supported in C++.
3) Multilevel Inheritance
Multilevel inheritance refers to a mechanism in OO technology where one can
inherit from a derived class, thereby making this derived class the base class
for the new class. As you can see in below flow diagram C is subclass or child
class of B and B is a child class of A.
Multilevel Inheritance example program in Java
Class X
{
public void methodX()
{
System.out.println("Class X method");
}
}
Class Y extends X
{
public void methodY()
{
System.out.println("class Y method");
}
}
Class Z extends Y
{
public void methodZ()
{
System.out.println("class Z method");

}
{
Z obj = new Z();
obj.methodX(); //calling grand parent class method
obj.methodY(); //calling parent class method
obj.methodZ(); //calling local method
}
}
4) Hierarchical Inheritance
In such kind of inheritance one class is inherited by many sub classes. In below
example class B,C and D inherits the same class A. A is parent class (or base
class) of B,C & D.
//Example
Class A
{
public void methodA()
{
System.out.println("method of Class A");
}
}
Class B extends A
{
{
System.out.println("method of Class B");
}
}
Class C extends A
{
public void methodC()
{
System.out.println("method of Class C");
}
}
Class D extends A
{
public void methodD()
{
System.out.println("method of Class D");
}
}
Class MyClass
{

{
System.out.println("method of Class B");
}
{
B obj1 = new B();
C obj2 = new C();
D obj3 = new D();
obj1.methodA();
obj2.methodA();
obj3.methodA();
}
}
The above would run perfectly fine with no errors and the output would be –
method of Class A
method of Class A
method of Class A
Super keyword and constructor in inheritance:
super keyword in java

The super keyword in java is a reference variable which is used to refer
immediate parent class object.
Whenever you create the instance of subclass, an instance of parent class is

created implicitly which is referred by super reference variable.
Usage of java super Keyword

1. super can be used to refer immediate parent class instance variable.
2. super can be used to invoke immediate parent class method.
3. super() can be used to invoke immediate parent class constructor.
1) super is used to refer immediate parent class instance variable.

We can use super keyword to access the data member or field of parent class. It
is used if parent class and child class have same fields.
1. class Animal{
2. String color="white";
3. }
4. class Dog extends Animal{
5. String color="black";
6. void printColor(){
7. System.out.println(color);//prints color of Dog class
8. System.out.println(super.color);//prints color of Animal class
9. }
10. }
11. class TestSuper1{
12. public static void main(String args[]){
13. Dog d=new Dog();
14. d.printColor();

15. }}
Output:
black
white
In the above example, Animal and Dog both classes have a common property color.
If we print color property, it will print the color of current class by default.
To access the parent property, we need to use super keyword.
2) super can be used to invoke parent class method

The super keyword can also be used to invoke parent class method. It should be
used if subclass contains the same method as parent class. In other words, it is
used if method is overridden.
1. class Animal{
2. void eat(){System.out.println("eating...");}
3. }
5. void eat(){System.out.println("eating bread...");}
6. void bark(){System.out.println("barking...");}
7. void work(){
8. super.eat();
9. bark();
10. }
11. }
15. d.work();
16. }}
Output:
eating...
barking...
In the above example Animal and Dog both classes have eat() method if we call
eat() method from Dog class, it will call the eat() method of Dog class by
default because priority is given to local.
To call the parent class method, we need to use super keyword.
3) super is used to invoke parent class constructor.

The super keyword can also be used to invoke the parent class constructor. Let's
see a simple example:
1. class Animal{
2. Animal(){System.out.println("animal is created");}

3. }
5. Dog(){
6. super();
7. System.out.println("dog is created");
8. }
9. }
13. }}
Output:
animal is created
dog is created
Note: super() is added in each class constructor automatically by compiler if

there is no super() or this().
As we know well that default constructor is provided by compiler automatically

if there is no constructor. But, it also adds super() as the first statement.
Another example of super keyword where super() is provided by the compiler

implicitly.
1. class Animal{
2. Animal(){System.out.println("animal is created");}
3. }
5. Dog(){
6. System.out.println("dog is created");
7. }
8. }
12. }}

Output:
animal is created
dog is created
super example: real use(Application of super)//Constructor chaining/constructor

re use
Let's see the real use of super keyword. Here, Emp class inherits Person class
so all the properties of Person will be inherited to Emp by default. To
initialize all the property, we are using parent class constructor from child
class. In such way, we are reusing the parent class constructor.
1. class Person{
2. int id;
3. String name;
4. Person(int id,String name){
5. this.id=id;
6. this.name=name;
7. }
8. }
9. class Emp extends Person{
10. float salary;
11. Emp(int id,String name,float salary){
12. super(id,name);//reusing parent constructor
13. this.salary=salary;
14. }
15. void display(){System.out.println(id+" "+name+" "+salary);}
16. }
18. public static void main(String[] args){
19. Emp e1=new Emp(1,"ankit",45000f);
20. e1.display();
21. }}
Output:
1 ankit 45000
method overriding:
In a class hierarchy, when a method in a subclass has the same name and type
signature as a method in its superclass, then the method in the subclass is said
to override the method in the superclass. When an overridden method is called
from within a subclass, it will always refer to the version of that method
defined by the subclass. The version of the method defined by the superclass
will be hidden.

Consider the following: // Method overriding.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// display k â€“ this overrides show() in A
void show() {
System.out.println("k: " + k);
}
}
class Override {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B
}
}
The output produced by this program is shown here:
k: 3
When show( ) is invoked on an object of type B, the version of show( ) defined

within B is used. That is, the versio n of show( ) inside B overrides the
version declared in A. If you wish to access the superclass version of an
overridden function, you can do so by using super. For example, in this version
of B, the superclass version of show( ) is invoked within the subclass' version.
This allows all instance variables to be displayed.
class B extends A {
int k;
super(a, b);
k = c;
}
void show() {
super.show(); // this calls A's show()

System.out.println("k: " + k);
}
}
If you substitute this version of A into the previous program, you will see the
following output:
i and j: 1 2
k: 3
Here, super.show( ) calls the superclass version of show( ). Method overriding

occurs only when the names and the type signatures of the two methods are
identical. If they are not, then the two methods are simply overloaded. For
example, consider this modified version of the preceding example:
// Methods with differing type signatures are overloaded â€“ not

// overridden.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}
// Create a subclass by extending class A.

class B extends A {
int k;
super(a, b);
k = c;
}
// overload show()
void show(String msg) {
System.out.println(msg + k);
}
}
class Override {
B subOb = new B(1, 2, 3);
subOb.show("This is k: "); // this calls show() in B
subOb.show(); // this calls show() in A
}
}
The output produced by this program is shown here:
This is k: 3
i and j: 1 2

The version of show( ) in B takes a string parameter. This makes its type
signature different from the one in A, which takes no parameters. Therefore, no
overriding (or name hiding) takes place.
Stop Inheritance – Final keywords:

If you make any class as final, you cannot extend it.
Example of final class

1. final class Bike{}
2.
3. class Honda1 extends Bike{
4. void run(){System.out.println("running safely with 100kmph");}
5.
7. Honda1 honda= new Honda();
8. honda.run();
9. }
10. }
Output:Compile Time Error
abstract class and abstract method(Abstract

Modifier):
Concept of Abstract Class

Consider the following class hierarchy consisting of a Shape class which is
inherited by three classes Rectangle , Circle and Triangle. The Shape class is
created to save on common attributes and methods shared by the three classes
Rectangle , Circle and Triangle. calculateArea() is one such method shared by
all 3 child classes and present in Shape class.

Now, assume you write code to create objects for the classes depicted above.
Lets observe how these objects will look in a practical world.
In this tutorial, you will learn-
 Concept of Abstract Class

 Abstract Method Java
 Abstract Class in Java & Method Important Points
An object of the class rectangle, will gives a rectangle , a shape we so

commonly observed in everyday life
An object of the class triangle, will gives a triangle , again a common everyday
shape

But what would an object of Class Shape look like in a practical world ??
If you observe the Shape class serves in our goal of achieving inheritance and
polymorphism . But it was not built to be instantiated.Such classes can be
labeled Abstract.An abstract class can not be instantiated.
Ex.
abstract class Shape{

// code
}
It is possible that you DO NOT label Shape class as Abstract and then
instantiate it. But such object will have no use in your code and will open a
room for potential errors. Hence this is not desirable.

Abstract Method Java
As we all know, the formula for calculation area for rectangle , circle &
triangle is different. The calculateArea() method will have to be overridden by
the inheriting classes.It makes so sense defining it in the Shape class, but we
need to make sure that all the inheriting classes do have the method.
Such methods can be labeled abstract.
abstract public void calculateArea();
For an abstract method , no implementation for is required. Only the signature

of the method is defined.
Abstract Class in Java: Important Points

 An abstract class may also have concrete (complete) methods.
 For design purpose, a class can be declared abstract even if it does not
contain any abstract methods
 Reference of an abstract class can point to objects of its sub-classes
thereby achieving run-time polymorphism Ex: Shape obj = new Rectangle();
 A class must be compulsorily labeled abstract , if it has one or more
abstract methods.
Understanding the real scenario of abstract class

In this example, Shape is the abstract class, its implementation is provided by
the Rectangle and Circle classes. Mostly, we don't know about the implementation
class (i.e. hidden to the end user) and object of the implementation class is
provided by the factory method.
A factory method is the method that returns the instance of the class. We will
learn about the factory method later.
In this example, if you create the instance of Rectangle class, draw() method of
Rectangle class will be invoked.
File: TestAbstraction1.java
1. abstract class Shape{

2. abstract void draw();
3. }
4. //In real scenario, implementation is provided by others i.e. unknown by e
nd user
5. class Rectangle extends Shape{
6. void draw(){System.out.println("drawing rectangle");}
7. }
8. class Circle1 extends Shape{

9. void draw(){System.out.println("drawing circle");}
10. }
11. //In real scenario, method is called by programmer or user
12. class TestAbstraction1{
14. Shape s=new Circle1();//In real scenario, object is provided through
method e.g. getShape() method
15. s.draw();
16. }
17. }
drawing circle
Another example of abstract class in java

File: TestBank.java
1. abstract class Bank{

2. abstract int getRateOfInterest();
3. }
4. class SBI extends Bank{
5. int getRateOfInterest(){return 7;}
6. }
7. class PNB extends Bank{
8. int getRateOfInterest(){return 8;}
9. }
10.
11. class TestBank{
13. Bank b;
14. b=new SBI();
15. System.out.println("Rate of Interest is: "+b.getRateOfInterest()+" %
");
16. b=new PNB();
17. System.out.println("Rate of Interest is: "+b.getRateOfInterest()+" %
");
18. }}
Rate of Interest is: 7 %

Rate of Interest is: 8 %

Creation and Implementation of an interface,
Interface reference, instanceof operator, Interface
inheritance:
An interface in java is a blueprint of a class. It has static constants and
abstract methods.
Interface in JAVA
The interface in java is a mechanism to achieve abstraction. There can be only

abstract methods in the java interface not method body. It is used to achieve
abstraction and multiple inheritance in Java.
Java Interface also represents IS-A relationship.
It cannot be instantiated just like abstract class.
Why use Java interface?

There are mainly three reasons to use interface. They are given below.
 It is used to achieve abstraction.

 By interface, we can support the functionality of multiple inheritance.
 It can be used to achieve loose coupling.
internal addition by compiler
The java compiler adds public and abstract keywords before the interface method.
More, it adds public, static and final keywords before data members.
In other words, Interface fields are public, static and final by default, and
methods are public and abstract.
nderstanding relationship between classes and interfaces

As shown in the figure given below, a class extends another class, an interface
extends another interface but a class implements an interface.

Java Interface Example
In this example, Printable interface has only one method, its implementation is
provided in the A class.
1. interface printable{
2. void print();
3. }
4. class A6 implements printable{
5. public void print(){System.out.println("Hello");}
6.
8. A6 obj = new A6();
9. obj.print();
10. }
11. }
Output:
Hello
Java Interface Example: Drawable

In this example, Drawable interface has only one method. Its implementation is
provided by Rectangle and Circle classes. In real scenario, interface is defined
by someone but implementation is provided by different implementation providers.
And, it is used by someone else. The implementation part is hidden by the user
which uses the interface.
File: TestInterface1.java
1. //Interface declaration: by first user

2. interface Drawable{
3. void draw();
4. }

5. //Implementation: by second user
6. class Rectangle implements Drawable{
7. public void draw(){System.out.println("drawing rectangle");}
8. }
9. class Circle implements Drawable{
10. public void draw(){System.out.println("drawing circle");}
11. }
12. //Using interface: by third user
13. class TestInterface1{
15. Drawable d=new Circle();//In real scenario, object is provided by me
thod e.g. getDrawable()
16. d.draw();
17. }}
Output:
drawing circle
Java Interface Example: Bank

Let's see another example of java interface which provides the implementation of
Bank interface.
File: TestInterface2.java
1. interface Bank{
2. float rateOfInterest();
3. }
4. class SBI implements Bank{
5. public float rateOfInterest(){return 9.15f;}
6. }
7. class PNB implements Bank{
8. public float rateOfInterest(){return 9.7f;}
9. }
10. class TestInterface2{
11. public static void main(String[] args){
12. Bank b=new SBI();
13. System.out.println("ROI: "+b.rateOfInterest());
14. }}
Output:
ROI: 9.15

Multiple inheritance in Java by interface
If a class implements multiple interfaces, or an interface extends multiple
interfaces i.e. known as multiple inheritance.
1. interface Printable{
2. void print();
3. }
4. interface Showable{
5. void show();
6. }
7. class A7 implements Printable,Showable{
9. public void show(){System.out.println("Welcome");}
10.
12. A7 obj = new A7();
13. obj.print();
14. obj.show();
15. }
16. }
Output:Hello
Welcome
Q) Multiple inheritance is not supported through class in java but it is

possible by interface, why?
As we have explained in the inheritance chapter, multiple inheritance is not
supported in case of class because of ambiguity. But it is supported in case of
interface because there is no ambiguity as implementation is provided by the
implementation class. For example:

2. void print();
3. }
4. interface Showable{
5. void print();
6. }
7.
8. class TestInterface3 implements Printable, Showable{
11. TestInterface3 obj = new TestInterface3();
12. obj.print();
13. }
14. }
Output:
Hello
As you can see in the above example, Printable and Showable interface have same
methods but its implementation is provided by class TestTnterface1, so there is
no ambiguity.
Interface inheritance
A class implements interface but one interface extends another interface .
2. void print();
3. }
4. interface Showable extends Printable{
5. void show();
6. }
7. class TestInterface4 implements Showable{
9. public void show(){System.out.println("Welcome");}
10.
12. TestInterface4 obj = new TestInterface4();
13. obj.print();
14. obj.show();
15. }
16. }
Output:
Hello
Welcome

Interface reference:
An interface reference can point to any object of a class that implements this
interface i.e. see the example below:
interface Foo{
void display();
}
public class TestFoo implements Foo{
void display(){
System.out.println(“Hello World”);
}
public static void main(String[] args){

Foo foo = new TestFoo();
foo.display();
}
java instanceof operator:

The java instanceof operator is used to test whether the object is an instance
of the specified type (class or subclass or interface).
The instanceof in java is also known as type comparison operator because it

compares the instance with type. It returns either true or false. If we apply
the instanceof operator with any variable that has null value, it returns false.
Simple example of java instanceof

Let's see the simple example of instance operator where it tests the current
class.
1. class Simple1{
3. Simple1 s=new Simple1();
4. System.out.println(s instanceof Simple1);//true
5. }
6. }
Output:true
An object of subclass type is also a type of parent class. For example, if Dog
extends Animal then object of Dog can be referred by either Dog or Animal class.
Another example of java instanceof operator

1. class Animal{}
2. class Dog1 extends Animal{//Dog inherits Animal
3.

5. Dog1 d=new Dog1();
6. System.out.println(d instanceof Animal);//true
7. }
8. }
Output:true
instanceof in java with a variable that have null value

If we apply instanceof operator with a variable that have null value, it returns
false. Let's see the example given below where we apply instanceof operator with
the variable that have null value.
1. class Dog2{
3. Dog2 d=null;
4. System.out.println(d instanceof Dog2);//false
5. }
6. }
Output:false
Downcasting with java instanceof operator

When Subclass type refers to the object of Parent class, it is known as
downcasting. If we perform it directly, compiler gives Compilation error. If you
perform it by typecasting, ClassCastException is thrown at runtime. But if we
use instanceof operator, downcasting is possible.
1. Dog d=new Animal();//Compilation error
If we perform downcasting by typecasting, ClassCastException is thrown at

runtime.
1. Dog d=(Dog)new Animal();

2. //Compiles successfully but ClassCastException is thrown at runtime
Possibility of downcasting with instanceof

Let's see the example, where downcasting is possible by instanceof operator.
1. class Animal { }
2.
3. class Dog3 extends Animal {
4. static void method(Animal a) {
5. if(a instanceof Dog3){
6. Dog3 d=(Dog3)a;//downcasting
7. System.out.println("ok downcasting performed");
8. }

9. }
10.
11. public static void main (String [] args) {
12. Animal a=new Dog3();
13. Dog3.method(a);
14. }
15.
16. }
Output:ok downcasting performed
Downcasting without the use of java instanceof

Downcasting can also be performed without the use of instanceof operator as
displayed in the following example:
1. class Animal { }
2. class Dog4 extends Animal {
3. static void method(Animal a) {
4. Dog4 d=(Dog4)a;//downcasting
5. System.out.println("ok downcasting performed");
6. }
7. public static void main (String [] args) {
8. Animal a=new Dog4();
9. Dog4.method(a);
10. }
11. }
Output:ok downcasting performed
Let's take closer look at this, actual object that is referred by a, is an

object of Dog class. So if we downcast it, it is fine. But what will happen if
we write:
1. Animal a=new Animal();

2. Dog.method(a);
3. //Now ClassCastException but not in case of instanceof operator
Understanding Real use of instanceof in java

Let's see the real use of instanceof keyword by the example given below.
1. interface Printable{}
2. class A implements Printable{
3. public void a(){System.out.println("a method");}
4. }
5. class B implements Printable{
6. public void b(){System.out.println("b method");}
7. }
8.

9. class Call{
10. void invoke(Printable p){//upcasting
11. if(p instanceof A){
12. A a=(A)p;//Downcasting
13. a.a();
14. }
15. if(p instanceof B){
16. B b=(B)p;//Downcasting
17. b.b();
18. }
19.
20. }
21. }//end of Call class
22.
23. class Test4{
25. Printable p=new B();
26. Call c=new Call();
27. c.invoke(p);
28. }
29. }
Output: b method
Dynamic method dispatch:
Runtime Polymorphism or Dynamic method dispatch

Method overriding is one of the ways in which Java supports Runtime
Polymorphism. Dynamic method dispatch is the mechanism by which a call to an
overridden method is resolved at run time, rather than compile time.
 When an overridden method is called through a superclass reference, Java

determines which version(superclass/subclasses) of that method is to be
executed based upon the type of the object being referred to at the time
the call occurs. Thus, this determination is made at run time.
 At run-time, it depends on the type of the object being referred to (not
the type of the reference variable) that determines which version of an
overridden method will be executed
 A superclass reference variable can refer to a subclass object. This is
also known as upcasting. Java uses this fact to resolve calls to
overridden methods at run time.

Therefore, if a superclass contains a method that is overridden by a subclass,
then when different types of objects are referred to through a superclass
reference variable, different versions of the method are executed. Here is an
example that illustrates dynamic method dispatch:
// A Java program to illustrate Dynamic Method

// Dispatch using multilevel inheritance
class A
{
void m1()
{
System.out.println("Inside A's m1 method");
}
}
class B extends A
{
// overriding m1()
void m1()
{
System.out.println("Inside B's m1 method");
}
}
class C extends A
{
// overriding m1()
void m1()
{
System.out.println("Inside C's m1 method");
}
}
// Driver class
class Dispatch
{
{

// object of type A
A a = new A();
// object of type B
B b = new B();
// object of type C
C c = new C();
// ref refers to an A object

A ref = a;
// calling A's version of m1()

ref.m1();
// now ref refers to a B object

ref = b;
// calling B's version of m1()

ref.m1();
// now ref refers to a C object

ref = c;
// calling C's version of m1()

ref.m1();
}
}
Output:
Inside A's m1 method

Inside B's m1 method
Inside C's m1 method
Explanation :
The above program creates one superclass called A and it’s two subclasses B and
C. These subclasses overrides m1( ) method.
1. Inside the main() method in Dispatch class, initially objects of

type A, B, and C are declared.
A a = new A(); // object of type A

B b = new B(); // object of type B
C c = new C(); // object of type C

2. Now a reference of type A, called ref, is also declared, initially
it will point to null.
A ref; // obtain a reference of type A
3. Now we are assigning a reference to each type of object (either A’s

or B’s or C’s) to ref, one-by-one, and uses that reference to invoke
m1( ). As the output shows, the version of m1( ) executed is
determined by the type of object being referred to at the time of
the call.
ref = a; // r refers to an A object

ref.m1(); // calling A's version of m1()

ref = b; // now r refers to a B object
ref.m1(); // calling B's version of m1()

ref = c; // now r refers to a C object
ref.m1(); // calling C's version of m1()

Runtime Polymorphism with Data Members
In Java, we can override methods only, not the variables(data members), so

runtime polymorphism cannot be achieved by data members. For example :
// Java program to illustrate the fact that

// runtime polymorphism cannot be achieved
// by data members
// class A
class A
{
int x = 10;
}
// class B
class B extends A
{
int x = 20;
}
// Driver class
public class Test

{
{
A a = new B(); // object of type B
// Data member of class A will be accessed

System.out.println(a.x);
}
}
Output:
10
Explanation : In above program, both the class A(super class) and B(sub class)
have a common variable ‘x’. Now we make object of class B, referred by ‘a’ which
is of type of class A. Since variables are not overridden, so the statement
“a.x” will always refer to data member of super class.
Advantages of Dynamic Method Dispatch
1. Dynamic method dispatch allow Java to support overriding of methods which

is central for run-time polymorphism.
2. It allows a class to specify methods that will be common to all of its
derivatives, while allowing subclasses to define the specific
implementation of some or all of those methods.
3. It also allow subclasses to add its specific methods subclasses to define
the specific implementation of some.
Static vs Dynamic binding
 Static binding is done during compile-time while dynamic binding is done

during run-time.
 private, final and static methods and variables uses static binding and
bonded by compiler while overridden methods are bonded during runtime
based upon type of runtime object
Difference between abstract class and interface

Abstract class and interface both are used to achieve abstraction where we can
declare the abstract methods. Abstract class and interface both can't be
instantiated.
But there are many differences between abstract class and interface that are
given below.
Abstract class Interface

Interface can have only abstract methods.
1) Abstract class can have abstract
Since Java 8, it can have default and static
and non-abstract methods.
methods also.
2) Abstract class doesn't support
Interface supports multiple inheritance.
multiple inheritance.
3) Abstract class can have final,
Interface has only static and final
non-final, static and non-static
variables.
variables.

4) Abstract class can provide the Interface can't provide the implementation
implementation of interface. of abstract class.
5) The abstract keyword is used to The interface keyword is used to declare
declare abstract class. interface.
6) Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }
Simply, abstract class achieves partial abstraction (0 to 100%) whereas
interface achieves fully abstraction (100%).
References:
1. Programming with Java A Primer – E.Balaguruswamy,Mc Grawhill
2. The Complete Reference, Java 2 (Fourth Edition),Herbert Schild, - TMH.
3. http://www.javacjava.com/tutorials.aspx
4. https://www.javatpoint.com/java-tutorial
5. https://way2java.com/java-lang/
6. https://www.tutorialspoint.com/java/
7. www.studytonight.com/java/
8. https://beginnersbook.com/2013/05/
9. www1.fs.cvut.cz/cz/u12110/prt/java/
10.A Programmer’s Guide to Java TM SCJP Certification A Comprehensive Primer-

Khalid A. Mughal , Rolf W. Rasmussen.
11. https://www.guru99.com/
12. www.c4learn.com/java/
13. www.geeksforgeeks.org/
14. www.sitesbay.com/java/
15.https://www.go4expert.com/articles/initialization-block-java-t1254/

Unit 4

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit 4

Uploaded by

Copyright:

Available Formats

UNIT-4

Inheritance and Interfaces

Use of Inheritance, Inheriting Data members and

3.In the terminology of Java, a class that is inherited is called a superclass.

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

The keyword used for inheritance is extends. Syntax:

public class ChildClass extends BaseClass {

Here is the complete example:

// A class to display the attributes of the vehicle

// A subclass which extends for vehicle

Color of Car : Blue

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

// A class to display the attributes of the vehicle

// A subclass which extends for vehicle

The output is:

Color of Car : 500

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Single Inheritance example program in Java

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Multilevel Inheritance example program in Java

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Super keyword and constructor in inheritance:

super keyword in java

Whenever you create the instance of subclass, an instance of parent class is

Usage of java super Keyword

1) super is used to refer immediate parent class instance variable.

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

2) super can be used to invoke parent class method

To call the parent class method, we need to use super keyword.

3) super is used to invoke parent class constructor.

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Note: super() is added in each class constructor automatically by compiler if

As we know well that default constructor is provided by compiler automatically

Another example of super keyword where super() is provided by the compiler

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

super example: real use(Application of super)//Constructor chaining/constructor

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

The output produced by this program is shown here:

When show( ) is invoked on an object of type B, the version of show( ) defined

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Here, super.show( ) calls the superclass version of show( ). Method overriding

// Methods with differing type signatures are overloaded â€“ not

// Create a subclass by extending class A.

The output produced by this program is shown here:

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Stop Inheritance – Final keywords:

Example of final class

Output:Compile Time Error

abstract class and abstract method(Abstract

Concept of Abstract Class

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

In this tutorial, you will learn-

 Concept of Abstract Class

An object of the class rectangle, will gives a rectangle , a shape we so

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

abstract class Shape{

Pradeep Laxkar , ITM Universe Vadodara (8140540626 , pradeep.laxkar@gmail.com)

Such methods can be labeled abstract.

abstract public void calculateArea();

For an abstract method , no implementation for is required. Only the signature

Abstract Class in Java: Important Points