Unit 3: Inheritance and interfaces

3.1 inheritance Basics

3.2 inheritance and constructors
3.3 super keyword
3.4 method overriding
3.5 polymorphism
3.6 dynamic binding
3.7 final keyword
3.8 abstract classes
3.9 access specifier
3.10 interfaces
Inheritance in Java
Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a
parent object. It is an important part of OOPs (Object Oriented programming system).
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 the parent class. Moreover,
you can add new methods and fields in your current class also.
Inheritance represents the IS-A relationship which is also known as a parent-child relationship.
 For Method Overriding (so runtime polymorphism can be achieved).
 For Code Reusability.
AD
The syntax of Java Inheritance
1. class Subclass-name extends Superclass-name
2. {
3. //methods and fields
4. }
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 a parent or superclass, 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. The
relationship between the two classes is Programmer IS-A Employee. It means that Programmer is a type
of Employee.
1. class Employee{
2. float salary=40000;
3. }
4. class Programmer extends Employee{
5. int bonus=10000;
6. public static void main(String args[]){
7. Programmer p=new Programmer();
8. System.out.println("Programmer salary is:"+p.salary);
9. System.out.println("Bonus of Programmer is:"+p.bonus);
10. }
11. }
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

When a class inherits another class, it is known as a single inheritance. In the example given below, Dog
class inherits the Animal class, so there is the single inheritance.
File: TestInheritance.java
1. class Animal{
2. void eat(){System.out.println("eating...");}
3. }
4. class Dog extends Animal{
5. void bark(){System.out.println("barking...");}
6. }
7. class TestInheritance{
8. public static void main(String args[]){
9. Dog d=new Dog();
10. d.bark();
11. d.eat();
12. }}
Output:
barking...
eating...
Multilevel Inheritance Example
When there is a chain of inheritance, it is known as multilevel inheritance. As you can see in the example
given below, BabyDog class inherits the Dog class which again inherits the Animal class, so there is a
multilevel inheritance.
File: TestInheritance2.java
1. class Animal{
2. void eat(){System.out.println("eating...");}
3. }
4. class Dog extends Animal{
5. void bark(){System.out.println("barking...");}
6. }
7. class BabyDog extends Dog{
8. void weep(){System.out.println("weeping...");}
9. }
 10. class TestInheritance2{
11. public static void main(String args[]){
12. BabyDog d=new BabyDog();
13. d.weep();
14. d.bark();
15. d.eat();
16. }}
Output:
weeping...
barking...
eating...
AD
Hierarchical Inheritance Example
When two or more classes inherits a single class, it is known as hierarchical inheritance. In the example
given below, Dog and Cat classes inherits the Animal class, so there is hierarchical inheritance.
AD
File: TestInheritance3.java
1. class Animal{
2. void eat(){System.out.println("eating...");}
3. }
4. class Dog extends Animal{
5. void bark(){System.out.println("barking...");}
6. }
7. class Cat extends Animal{
8. void meow(){System.out.println("meowing...");}
9. }
10. class TestInheritance3{
11. public static void main(String args[]){
12. Cat c=new Cat();
13. c.meow();
14. c.eat();
15. //c.bark();//C.T.Error
16. }}
Output:
meowing...
eating...

Constructors in Java
A constructor in Java is similar to a method with a few differences. Constructor has the same name as
the class name. A constructor doesn't have a return type.
A Java program will automatically create a constructor if it is not already defined in the program. It is
executed when an instance of the class is created.
A constructor cannot be static, abstract, final or synchronized. It cannot be overridden.
Java has two types of constructors:
1. Default constructor
2. Parameterized constructor
1. example of constructor in Single inheritance
In single level inheritance, the constructor of the base class is executed first.
OrderofExecution1.java
1. /* Parent Class */
2. class ParentClass
3. {
4. /* Constructor */
5. ParentClass()
 6. {
7. System.out.println("ParentClass constructor executed.");
8. }
9. }
10. /* Child Class */
11. class ChildClass extends ParentClass
12. {
13. /* Constructor */
14. ChildClass()
15. {
16. System.out.println("ChildClass constructor executed.");
17. }
18. }
19. public class OrderofExecution1
20. {
21. /* Driver Code */
22. public static void main(String ar[])
23. {
24. /* Create instance of ChildClass */
25. System.out.println("Order of constructor execution...");
26. new ChildClass();
27. }
28. }
Output:
Order of constructor execution...
ParentClass constructor executed.
ChildClass constructor executed.
In the above code, after creating an instance of ChildClass the ParentClass constructor is invoked first
and then the ChildClass.
2. example of constructor in Multilevel inheritance
In multilevel inheritance, all the upper class constructors are executed when an instance of bottom most
child class is created.
OrderofExecution2.java
1. class College
2. {
3. /* Constructor */
4. College()
5. {
6. System.out.println("College constructor executed");
7. }
8. }
9. class Department extends College
10. {
11. /* Constructor */
12. Department()
13. {
14. System.out.println("Department constructor executed");
15. }
16. }
17. class Student extends Department
18. {
19. /* Constructor */
20. Student()
21. {
 22. System.out.println("Student constructor executed");
23. }
24. }
25. public class OrderofExecution2
26. {
27. /* Driver Code */
28. public static void main(String ar[])
29. {
30. /* Create instance of Student class */
31. System.out.println("Order of constructor execution in Multilevel inheritance...");
32. new Student();
33. }
34. }
Output:
Order of constructor execution in Multilevel inheritance...
College constructor executed
Department constructor executed
Student constructor executed
In the above code, an instance of Student class is created and it invokes the constructors of College,
Department and Student accordingly.
3. example of same class constructor using this keyword
Here, inheritance is not implemented. But there can be multiple constructors of a single class and those
constructors can be accessed using this keyword.
OrderofExecution3.java
1. public class OrderofExecution3
2. {
3. /* Default constructor */
4. OrderofExecution3()
5. {
6. this("CallParam");
7. System.out.println("Default constructor executed.");
8. }
9. /* Parameterized constructor */
10. OrderofExecution3(String str)
11. {
12. System.out.println("Parameterized constructor executed.");
13. }
14. /* Driver Code */
15. public static void main(String ar[])
16. {
17. /* Create instance of the class */
18. System.out.println("Order of constructor execution...");
19. OrderofExecution3 obj = new OrderofExecution3();
20. }
21. }
Output:
Order of constructor execution...
Parameterized constructor executed.
Default constructor executed.
In the above code, the parameterized constructor is called first even when the default constructor is
called while object creation. It happens because this keyword is used as the first line of the default
constructor.
AD
4. example of Calling superclass constructor using super keyword
A child class constructor or method can access the base class constructor or method using the super
keyword.
OrderofExecution4.java
1. /* Parent Class */
2. class ParentClass
3. {
4. int a;
5. ParentClass(int x)
6. {
7. a = x;
8. }
9. }
10.
11. /* Child Class */
12. class ChildClass extends ParentClass
13. {
14. int b;
15. ChildClass(int x, int y)
16. {
17. /* Accessing ParentClass Constructor */
18. super(x);
19. b = y;
20. }
21. /* Method to show value of a and b */
22. void Show()
23. {
24. System.out.println("Value of a : "+a+"\nValue of b : "+b);
25. }
26. }
27.
28. public class OrderofExecution4
29. {
30. /* Driver Code */
31. public static void main(String ar[])
32. {
33. System.out.println("Order of constructor execution...");
34. ChildClass d = new ChildClass(79, 89);
35. d.Show();
36. }
37. }
Output:
Order of constructor execution...
Value of a : 79
Value of b : 89
In the above code, the ChildClass calls the ParentClass constructor using a super keyword that
determines the order of execution of constructors.
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.
super example: real 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. }
17. class TestSuper5{
18. public static void main(String[] args){
19. Emp e1=new Emp(1,"ankit",45000f);
20. e1.display();
21. }}
Test it Now
Output:
1 ankit 45000
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 a subclass provides the specific implementation of the method that has been declared
by one of its parent class, it is known as method overriding.
Usage of Java Method Overriding
 Method overriding is used to provide the specific implementation of a method which is already
provided by its superclass.
 Method overriding is used for runtime polymorphism
Rules for Java Method Overriding
1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an 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 are the same, and there is IS-A
relationship between the classes, so there is method overriding.
1. //Java Program to illustrate the use of Java Method Overriding
2. //Creating a parent class.
3. class Vehicle{
4. //defining a method
5. void run(){System.out.println("Vehicle is running");}
6. }
7. //Creating a child class
8. class Bike2 extends Vehicle{
9. //defining the same method as in the parent class
 10. void run(){System.out.println("Bike is running safely");}
11.
12. public static void main(String args[]){
13. Bike2 obj = new Bike2();//creating object
14. obj.run();//calling method
15. }
16. }
Test it Now
Output:
Bike is running safely
Polymorphism in Java
Polymorphism in Java is a concept by which we can perform a single action in different ways.
Polymorphism is derived from 2 Greek words: poly and morphs. The word "poly" means many and
"morphs" means forms. So polymorphism means many forms.
There are two types of polymorphism in Java: compile-time polymorphism and runtime polymorphism.
We can perform polymorphism in java by method overloading and method overriding.
If you overload a static method in Java, it is the example of compile time polymorphism. Here, we will
focus on runtime polymorphism in java.
Runtime Polymorphism in Java
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.
Let's first understand the upcasting before Runtime Polymorphism.
Upcasting
If the reference variable of Parent class refers to the object of Child class, it is known as upcasting. For
example:

1. class A{}
2. class B extends A{}
1. A a=new B();//upcasting
For upcasting, we can use the reference variable of class type or an interface type. For Example:
1. interface I{}
2. class A{}
3. class B extends A implements I{}
Here, the relationship of B class would be:
B IS-A A
B IS-A I
B IS-A Object
Since Object is the root class of all classes in Java, so we can write B IS-A Object.
Example of Java Runtime Polymorphism
In this example, we are creating two classes Bike and Splendor. Splendor class extends Bike class and
overrides its run() method. We are calling the run method by the reference variable of Parent class. Since
it refers to the subclass object and subclass method overrides the Parent class method, the subclass
method is invoked at runtime.
Since method invocation is determined by the JVM not compiler, it is known as runtime polymorphism.
1. class Bike{
2. void run(){System.out.println("running");}
 3. }
4. class Splendor extends Bike{
5. void run(){System.out.println("running safely with 60km");}
6.
7. public static void main(String args[]){
8. Bike b = new Splendor();//upcasting
9. b.run();
10. }
11. }
Test it Now
Output:
running safely with 60km.
Dynamic Polymorphism
Dynamic polymorphism is a process or mechanism in which a call to an overridden method is to resolve
at runtime rather than compile-time. It is also known as runtime polymorphism or dynamic method
dispatch. We can achieve dynamic polymorphism by using the method overriding.
In this process, an overridden method is called through a 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.
Properties of Dynamic Polymorphism
 It decides which method is to execute at runtime.
 It can be achieved through dynamic binding.
 It happens between different classes.
 It is required where a subclass object is assigned to a super-class object for dynamic
polymorphism.
 Inheritance involved in dynamic polymorphism.
AD
Method Overriding
It provides a specific implementation to a method that is already present in the parent class. it is used to
achieve run-time polymorphism. Remember that, it is not possible to override the static method. Hence,
we cannot override the main() method also because it is a static method.
Rules for Method Overriding
 The name of the method must be the same as the name of the parent class method.
 The number of parameters and the types of parameters must be the same as in the parent class.
 There must exist an IS-A relationship (inheritance).
We call an overridden method through a reference of the parent class. The type of object decides which
method is to be executed and it is decided by the JVM at runtime.
Example of Dynamic Polymorphism
In the following example, we have created two classes named Sample and Demo. The Sample class is a
parent class and the Demo class is a child or derived class. The child class is overriding the dispaly()
method of the parent class.
We have assigned the child class object to the parent class reference. So, in order to determine which
method would be called, the type of the object would be decided by the JVM at run-time. It is the type
of object that determines which version of the method would be called (not the type of reference).
Demo.java
1. //parent class
2. class Sample
3. {
4. //method of the parent class
5. public void display()
6. {
7. System.out.println("Overridden Method");
8. }
9. }
 10. //derived or child class
11. public class Demo extends Sample
12. {
13. //method of child class
14. public void display()
15. {
16. System.out.println("Overriding Method");
17. }
18. public static void main(String args[])
19. {
20. //assigning a child class object to parent class reference
21. Sample obj = new Demo();
22. //invoking display() method
23. obj.display();
24. }
25. }
Output:
Overriding Method
Example of Method Overriding
DynamicPolymorphismExample.java
1. public class DynamicPolymorphismExample
2. {
3. public static void main(String args[])
4. {
5. //assigning a child class object to a parent class reference
6. Fruits fruits = new Mango();
7. //invoking the method
8. fruits.color();
9. }
10. }
11. //parent class
12. class Fruits
13. {
14. public void color()
15. {
16. System.out.println("Parent class method is invoked.");
17. }
18. }
19. //derived or child class that extends the parent class
20. class Mango extends Fruits
21. {
22. //overrides the color() method of the parent class
23. @Override
24. public void color()
25. {
26. System.out.println("The child class method is invoked.");
27. }
28. }
Output:
The child class method is invoked.

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:
 1. variable
2. method
3. 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. We will have detailed learning
of these. Let's first learn the basics of final keyword.
Java Final Keyword
 Stop Value Change
 Stop Method Overridding
 Stop Inheritance
1) Java final variable
If you make any variable as final, you cannot change the value of final variable(It will be constant).
Example of final variable
There is a final variable speedlimit, we are going to change the value of this variable, but It can't be
changed because final variable once assigned a value can never be changed.
1. class Bike9{
2. final int speedlimit=90;//final variable
3. void run(){
4. speedlimit=400;
5. }
6. public static void main(String args[]){
7. Bike9 obj=new Bike9();
8. obj.run();
9. }
10. }//end of class
Test it Now
Output:Compile Time Error

2) Java final method

If you make any method as final, you cannot override it.
Example of final method
1. class Bike{
2. final void run(){System.out.println("running");}
3. }
4. class Honda extends Bike{
5. void run(){System.out.println("running safely with 100kmph");}
6. public static void main(String args[]){
7. Honda honda= new Honda();
8. honda.run();
9. }
10. }
Test it Now
Output:Compile Time Error
3) Java final class
If you make any class as final, you cannot extend it.
Example of final class
1. final class Bike{}
2. class Honda1 extends Bike{
3. void run(){System.out.println("running safely with 100kmph");}
4. public static void main(String args[]){
5. Honda1 honda= new Honda1();
6. honda.run();
7. }
 8. }
Test it Now
Output:Compile Time Error
Abstract class in Java
A class which is declared with the abstract keyword is known as an abstract class in Java. It can have
abstract and non-abstract methods (method with the body).
Before learning the Java abstract class, let's understand the abstraction in Java first.

Abstraction in Java
Abstraction is a process of hiding the implementation details and showing only functionality to the user.
Another way, it shows only essential things to the user and hides the internal details, for example,
sending SMS where you type the text and send the message. You don't know the internal processing
about the message delivery.
Abstraction lets you focus on what the object does instead of how it does it.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
1. Abstract class (0 to 100%)
2. Interface (100%)

Abstract class in Java

A class which is declared as abstract is known as an abstract class. It can have abstract and non-abstract
methods. It needs to be extended and its method implemented. It cannot be instantiated.
Points to Remember( Rules for Java Abstract class)
 An abstract class must be declared with an abstract keyword.
 It can have abstract and non-abstract methods.
 It cannot be instantiated.
 It can have constructors and static methods also.
 It can have final methods which will force the subclass not to change the body of the method.
Example of abstract class
1. abstract class A{}

Abstract Method in Java

A method which is declared as abstract and does not have implementation is known as an abstract
method.
Example of abstract method
1. abstract void printStatus();//no method body and abstract

Example of Abstract class that has an abstract method

In this example, Bike is an abstract class that contains only one abstract method run. Its implementation
is provided by the Honda class.
1. abstract class Bike{
2. abstract void run();
3. }
4. class Honda4 extends Bike{
5. void run(){System.out.println("running safely");}
6. public static void main(String args[]){
7. Bike obj = new Honda4();
8. obj.run();
9. }
10. }
Test it Now
running safely
Access Modifiers in Java
There are two types of modifiers in Java: access modifiers and non-access modifiers.
The access modifiers in Java specifies the accessibility or scope of a field, method, constructor, or class.
We can change the access level of fields, constructors, methods, and class by applying the access
modifier on it.
There are four types of Java access modifiers:
1. Private: The access level of a private modifier is only within the class. It cannot be accessed from
outside the class.
2. Default: The access level of a default modifier is only within the package. It cannot be accessed
from outside the package. If you do not specify any access level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and outside the
package through child class. If you do not make the child class, it cannot be accessed from
outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed from within the
class, outside the class, within the package and outside the package.
There are many non-access modifiers, such as static, abstract, synchronized, native, volatile, transient,
etc. Here, we are going to learn the access modifiers only.

Understanding Java Access Modifiers

Let's understand the access modifiers in Java by a simple table.
Access withi within outside outside
Modifier n package package by package
class subclass only
Private Y N N N
Default Y Y N N
Protected Y Y Y N
Public Y Y Y Y

1) Private
The private access modifier is accessible only within the class.
Simple example of private access modifier
In this example, we have created two classes A and Simple. A class contains private data member and
private method. We are accessing these private members from outside the class, so there is a compile-
time error.
1. class A{
2. private int data=40;
3. private void msg(){System.out.println("Hello java");}
4. }
5.
6. public class Simple{
7. public static void main(String args[]){
8. A obj=new A();
9. System.out.println(obj.data);//Compile Time Error
10. obj.msg();//Compile Time Error
11. }
12. }
Role of Private Constructor
If you make any class constructor private, you cannot create the instance of that class from outside the
class. For example:
1. class A{
2. private A(){}//private constructor
3. void msg(){System.out.println("Hello java");}
4. }
5. public class Simple{
6. public static void main(String args[]){
 7. A obj=new A();//Compile Time Error
8. }
9. }
Note: A class cannot be private or protected except nested class.

2) Default
If you don't use any modifier, it is treated as default by default. The default modifier is accessible only
within package. It cannot be accessed from outside the package. It provides more accessibility than
private. But, it is more restrictive than protected, and public.
Example of default access modifier
In this example, we have created two packages pack and mypack. We are accessing the A class from
outside its package, since A class is not public, so it cannot be accessed from outside the package.
1. //save by A.java
2. package pack;
3. class A{
4. void msg(){System.out.println("Hello");}
5. }
1. //save by B.java
2. package mypack;
3. import pack.*;
4. class B{
5. public static void main(String args[]){
6. A obj = new A();//Compile Time Error
7. obj.msg();//Compile Time Error
8. }
9. }
In the above example, the scope of class A and its method msg() is default so it cannot be accessed from
outside the package.
3) Protected
The protected access modifier is accessible within package and outside the package but through
inheritance only.
The protected access modifier can be applied on the data member, method and constructor. It can't be
applied on the class.
It provides more accessibility than the default modifer.
Example of protected access modifier
AD
In this example, we have created the two packages pack and mypack. The A class of pack package is
public, so can be accessed from outside the package. But msg method of this package is declared as
protected, so it can be accessed from outside the class only through inheritance.
1. //save by A.java
2. package pack;
3. public class A{
4. protected void msg(){System.out.println("Hello");}
5. }
//save by B.java
1. package mypack;
2. import pack.*;
3. class B extends A{
4. public static void main(String args[]){
5. B obj = new B();
6. obj.msg();
7. }
8. }
Output:Hello
4) Public
The public access modifier is accessible everywhere. It has the widest scope among all other modifiers.
Example of public access modifier
1. //save by A.java
2.
3. package pack;
4. public class A{
5. public void msg(){System.out.println("Hello");}
6. }
1. //save by B.java
2.
3. package mypack;
4. import pack.*;
5.
6. class B{
7. public static void main(String args[]){
8. A obj = new A();
9. obj.msg();
10. }
11. }
Output:Hello
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.
In other words, you can say that interfaces can have abstract methods and variables. It cannot have a
method body.
Java Interface also represents the IS-A relationship.
It cannot be instantiated just like the abstract class.
Since Java 8, we can have default and static methods in an interface.
Since Java 9, we can have private methods in an interface.
Why use Java interface?
There are mainly three reasons to use interface. They are given below.
1) It is used to achieve abstraction.
2) By interface, we can support the functionality of multiple inheritance.
3) It can be used to achieve loose coupling.
How to declare an interface?
An interface is declared by using the interface keyword. It provides total abstraction; means all the
methods in an interface are declared with the empty body, and all the fields are public, static and final by
default. A class that implements an interface must implement all the methods declared in the interface.
Syntax:
1. interface <interface_name>{
2.
3. // declare constant fields
4. // declare methods that abstract
5. // by default.
6. }