Inheritance in Java

• Inheritance in java is a mechanism in which one

object acquires all the properties and behaviors of
parent object.
• The idea behind inheritance in java is that you can
create new classes that are built upon existing
classes. When you inherit from an existing class, you
can reuse methods and fields of parent class, and
you can add new methods and fields also.
• Inheritance represents the IS-A relationship, also
known as parent-child relationship.
Use of inheritance in java

• For Method Overriding (so runtime

polymorphism can be achieved).

• For Code Reusability.

Syntax of Java Inheritance
class Subclass-name extends Superclass-name
{
//methods and fields
}

• The extends keyword indicates that you are making a

new class that derives from an existing class. The
meaning of "extends" is to increase the functionality.

• In the terminology of Java, a class which is inherited is

called parent or super class and the new class is called
child or subclass.
 Java Inheritance Example

• As displayed in the above figure, Programmer is the subclass

and Employee is the superclass.
• Relationship between two classes is Programmer IS-A Employee.
• It means that Programmer is a type of Employee.
Java Inheritance Example
class Employee{
float salary=40000;
}
class Programmer extends Employee{
int bonus=10000;
public static void main(String args[]){
Programmer p=new Programmer();
System.out.println("Programmer salary is:"+p.salary);
System.out.println("Bonus of Programmer is:"+p.bonus);
}
} Output : Programmer salary is:40000.0
Bonus of programmer is:10000
Types of inheritance in java
• On the basis of class, there can be three types of
inheritance in java: single, multilevel and hierarchical.

• In java programming, multiple and hybrid inheritance

is supported through interface only. We will learn
about interfaces later.
Single Inheritance Example
class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");
} class TestInheritance{
} public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}
}
Output:
barking... eating...
 Multilevel Inheritance
Example
class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}

class BabyDog extends Dog{

void weep(){System.out.println("weeping...");}
}
 Multilevel Inheritance
Example
class TestInheritance2{
public static void main(String args[]){
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}}

Output:

weeping...
barking...
eating...
 Hierarchical Inheritance
Example
class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class Cat extends Animal{
void meow(){System.out.println("meowing...");}
}
 Hierarchical Inheritance
Example
class TestInheritance3{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
//c.bark();//C.T.Error
}}

Output:

meowing...
eating...
 Method Overriding in
Java
• If subclass (child class) has the same
method as declared in the parent class, it is
known as method overriding in java.

• In other words, If subclass provides the

specific implementation of the method that
has been provided by one of its parent
class, it is known as method overriding.
 Usage of Java Method
Overriding
• Method overriding is used to provide
specific implementation of a method that is
already provided by its super class.

• Method overriding is used for runtime

polymorphism
 Rules for Java Method
Overriding
• method must have same name as in the
parent class
• method must have same parameter as in
the parent class.
• must be IS-A relationship (inheritance).
 Example of method
overriding
• In this example, we have defined the run
method in the subclass as defined in the parent
class but it has some specific implementation.
The name and parameter of the method is
same and there is IS-A relationship between the
classes, so there is method overriding.

class Vehicle{
void run(){System.out.println("Vehicle is running");}
}
 Example of method
overriding
class Bike2 extends Vehicle{
void run(){System.out.println("Bike is running
safely");}

public static void main(String args[]){

Bike2 obj = new Bike2();
obj.run();
}
 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.
 super keyword in java

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.
super : used to invoke immediate
parent class instance variable.
class Animal{ class TestSuper1{
String color="white"; public static void main(String args[]){
Dog d=new Dog();
} d.printColor();
}}
class Dog extends Animal{
Output: black
String color="black";
white
void printColor(){
System.out.println(color);//prints color of Dog class
System.out.println(super.color);//prints color of Animal class

}
}
 super : used to refer immediate
parent class method.
class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void eat(){System.out.println("eating bread...");}
void bark(){System.out.println("barking...");}
void work()
class TestSuper2{
{ public static void main(String args[]){
super.eat(); Dog d=new Dog();
bark(); d.work();
}}
}
} Output: eating...
barking...
super : used to invoke immediate
parent class conctructor.
class Animal{
Animal(){System.out.println("animal is created");}
} class TestSuper3{
public static void main(String args[]){

class Dog extends Animal{ Dog d=new Dog();

Dog(){ }
}
super(); Output animal is created
System.out.println("dog is created"); dog is created
}
}
 Another super example
class Person{
int id;
String name;
Person(int id,String name){
this.id=id;
this.name=name;
}
}
 Another super
example…continued
class Emp extends Person{
float salary;
Emp(int id,String name,float salary)
{
super(id,name);//reusing parent constructor
this.salary=salary;
}
void display(){System.out.println(id+" "+name+"
"+salary);}
}
 Another super
example…continued
class TestSuper5{
public static void main(String[] args)
{
Emp e1=new Emp(1,"ankit",45000f);
e1.display();
}
}
Output:
1 ankit 45000
 Final Keyword In Java

The final keyword in java is used to restrict the user.

The java final keyword can be used in many context.
Final can be:

• variable

• method

• class
 Final Keyword In Java
The final keyword in java is used to restrict the user. The java final
keyword can be used in many context. Final can be:
• variable
• method
• Class
The final keyword can be applied with the variables, a final variable that
have no value it is called blank final variable or uninitialized final variable.
It can be initialized in the constructor only. The blank final variable can be
static also which will be initialized in the static block only.
 Java final variable
• If you make any variable as final, you cannot
change the value of final variable(It will be
constant).
class Bike9{
final int speedlimit=90;//final variable
void run(){
speedlimit=400;
}
public static void main(String args[]){
Bike9 obj=new Bike9();
obj.run();
}
}//end of class Output:Compile Time Error
 Java final method
• If you make any method as final, you cannot override it.
Example of final method
class Bike{
final void run(){System.out.println("running");}
}

class Honda extends Bike{

void run(){System.out.println("running safely with 100kmph");} //Error

public static void main(String args[]){

Honda honda= new Honda();
honda.run();
}
}
Output: Compile Time Error
 Java final class
• If you make any class as final, you cannot extend it.
• Example
final class Bike{}

class Honda1 extends Bike{ //Error

void run(){System.out.println("running safely with 100kmph");}

public static void main(String args[]){

Honda1 honda= new Honda();
honda.run();
}
}
Output:Compile Time Error
 Blank or uninitialized
final variable
• A final variable that is not initialized at the time of
declaration is known as blank final variable.

• If you want to create a variable that is initialized at

the time of creating object and once initialized may
not be changed, it is useful. For example PAN CARD
number of an employee.

• It can be initialized only in constructor.

 Example of blank final
variable
class Student{
int id;
String name;
final String PAN_CARD_NUMBER;
...
}
 Dynamic Method
Dispatch
• Runtime polymorphism or Dynamic Method
Dispatch is a process in which a call to an
overridden method is resolved at runtime
rather than compile-time.

• In this process, an overridden method is

called through the reference variable of a
superclass. The determination of the method
to be called is based on the object being
referred to by the reference variable.
 Upcasting
• When reference variable of Parent class refers
to the object of Child class, it is known as
upcasting. For example:

class A{}
class B extends A{}
A a=new B();//upcasting
 Dynamic Method
Dispatch Example
class Bank{
float getRateOfInterest(){return 0;}
}
class SBI extends Bank{
float getRateOfInterest(){return 8.4f;}
}
class ICICI extends Bank{
float getRateOfInterest(){return 7.3f;}
}
class AXIS extends Bank{
float getRateOfInterest(){return 9.7f;}
}
 Dynamic Method
Dispatch Example
class TestPolymorphism{
public static void main(String args[]){
Bank b;
b=new SBI();
System.out.println("SBI Rate of Interest: "+b.getRateOfInterest());
b=new ICICI();
System.out.println("ICICI Rate of Interest: "+b.getRateOfInterest());

b=new AXIS();
System.out.println("AXIS Rate of Interest: "+b.getRateOfInterest());

}
}
 Abstractionin Java
• Abstraction is a process of hiding the
implementation details and showing only
functionality to the user.
Ways to achieve Abstaction
There are two ways to achieve abstraction in
java
• Abstract class (0 to 100%)
• Interface (100%)
 Abstract class in Java
• A class that is declared with abstract
keyword, is known as abstract class in java.

• It can have abstract and non-abstract

methods (method with body).

• It needs to be extended and its method

implemented.

• It cannot be instantiated.
 Abstract class in Java
abstract class Shape{
abstract void draw();
}
//In real scenario, implementation is provided by others i.e. unk
//nown by end user
class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle");}
}
class Circle1 extends Shape{
void draw(){System.out.println("drawing circle");}
}
 Abstract class in Java
//In real scenario, method is called by programmer or u
//ser
class TestAbstraction1{
public static void main(String args[]){
Shape s=new Circle1();//In real scenario, object is provi
//ded through method e.g. getShape() method
s.draw();
}
}
 Interface in Java
• An interface in java is a blueprint of a class. It has
static constants and abstract methods.
• 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.

 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.

interface printable{
void print();
}
class A implements printable{
public void print(){System.out.println("Hello");}

public static void main(String args[]){

A obj = new A();
obj.print();
}
}
 Java Interface Example2
//Interface declaration: by first user
interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
}
 Java Interface
Example2…continued
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle(); //In real scenario, object is provided
//by method e.g. getDrawable()
d.draw();
}
}
Why multiple inheritance is
not supported in java?
• To reduce the complexity and simplify the
language, multiple inheritance is not supported in
java.
• Consider a scenario where A, B and C are three
classes. The C class inherits A and B classes. If A and
B classes have same method and you call it from
child class object, there will be ambiguity to call
method of A or B class.
• Since compile time errors are better than runtime
errors, java renders compile time error if you inherit 2
classes. So whether you have same method or
different, there will be compile time error now.
class A{
void msg(){System.out.println("Hello");}
}
class B{
void msg(){System.out.println("Welcome");}
}
class C extends A,B{//suppose if it were

public static void main(String args[]){

C obj=new C();
obj.msg();//Now which msg() method would be invoked?
}
}

Output :

Compile Time Error

 Multiple Inheritance in
Java
• If a class implements multiple interfaces, or an
interface extends multiple interfaces i.e. known as
multiple inheritance.
Multiple Inheritance in Java
interface Printable{
void print();
}
interface Showable{
void show();
}
class A implements Printable , Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){

A obj = new A ();
obj.print();
obj.show();
}
}
 Interface inheritance
• A class implements interface but one interface extends another
interface
interface Printable{
void print();
}
interface Showable extends Printable{
void show();
}
class TestInterface4 implements Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){

TestInterface4 obj = new TestInterface4();
obj.print();
obj.show();
}
}
Difference between abstract
class and interface
Abstract class Interface

Interface can have only abstract methods.

1) Abstract class can have abstract and
Since Java 8, it can have default and static
non-abstract methods.
methods also.

2) Abstract class doesn't support multiple

Interface supports multiple inheritance.
inheritance.

3) Abstract class can have final, non-final,

Interface has only static and final variables.
static and non-static 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 declare The interface keyword is used to declare
abstract class. interface.

6) Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }