Multiple Inheritance:

Inheritance: It is the mechanism in Java by which one class is allowed to

inherit the features (fields and methods) of another class. In Java, Inheritance
means creating new classes based on existing ones. A class that inherits from
another class can reuse the methods and fields of that class.
Why Do We Need Java Inheritance?
• Code Reusability: The code written in the Superclass is common to all
subclasses. Child classes can directly use the parent class code.
• Method Overriding: Method Overriding is achievable only through
Inheritance. It is one of the ways by which Java achieves Run Time
Polymorphism.
• Abstraction: The concept of abstract where we do not have to provide all
details, is achieved through inheritance. Abstraction only shows the
functionality to the user.
Terminologies Used in Java Inheritance
• Class: Class is a set of objects which shares common characteristics/
behavior and common properties/ attributes. Class is not a real-world
entity. It is just a template or blueprint or prototype from which objects
are created.
• Super Class/Parent Class: The class whose features are inherited is
known as a superclass(or a base class or a parent class).
• Sub Class/Child Class: The class that inherits the other class is known
as a subclass(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.
How to Use Inheritance in Java?
The extends keyword is used for inheritance in Java. Using the extends
keyword indicates you are derived from an existing class. In other words,
“extends” refers to increased functionality.
Syntax :
class DerivedClass extends BaseClass
{
//methods and fields
}
Inheritance Types
1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance
// Java program to illustrate the concept of single inheritance

import java.io.*;
import java.lang.*;
import java.util.*;

// Parent class
class Parent {
public void printparent()
{
System.out.println("parent");
}
}

class Child extends Parent {

public void printchild() {
System.out.println("child");
}
}

public class SingleInheritance {

public static void main(String[] args)
{
Child obj = new Child();
obj.printparent();
obj.printchild();
obj.printparent();
}
}
Multilevel
// Importing required libraries
import java.io.*;
import java.lang.*;
import java.util.*;

// Parent class One

class GrandParent {

public void printGrandparent() {

System.out.println("GrandParent");
}
}

// Child class Parent inherits from class GrandParent

class Parent extends GrandParent {
public void printparent() {
System.out.println("parent");
}
}

// Child class Child inherits from class Parent

class Child extends Parent {

public void printchild() {

System.out.println("child");
}
}
public class MultilevelInheritance {
public static void main(String[] args) {
// Creating an object of class Child
Child obj = new Child();

// Calling method from class GrandParent

obj.printGrandparent();

// Calling method from class Parent

obj.printparent();

// Calling method from class Child

obj.printchild();
}
}
Hierarchical Inheritance

// Java program to illustrate the

// concept of Hierarchical inheritance

class A {
public void print_A() { System.out.println("Class A"); }
}

class B extends A {
public void print_B() { System.out.println("Class B"); }
}

class C extends A {
public void print_C() { System.out.println("Class C"); }
}

class D extends A {
public void print_D() { System.out.println("Class D"); }
}

// Driver Class
public class Test {
public static void main(String[] args)
{
B obj_B = new B();
obj_B.print_A();
obj_B.print_B();

C obj_C = new C();

 obj_C.print_A();
obj_C.print_C();

D obj_D = new D();

obj_D.print_A();
obj_D.print_D();
}
}

Multiple Inheritance: In Multiple inheritances, one class can have more than one
superclass and inherit features from all parent classes. Please note that Java
does not support multiple inheritances with classes. In Java, we can achieve
multiple inheritances only through Interfaces. In the image below, Class C is
derived from interfaces A and B.

// Java program to illustrate the

// concept of Multiple inheritance
import java.io.*;
import java.lang.*;
import java.util.*;
interface One {
public void print_One();
}

interface Two {
public void print_Two();
}

interface Three extends One, Two {

public void print_One();
}
class Child implements Three {
@Override public void print_One()
{
System.out.println("One");
}

public void print_Two() { System.out.println("Two"); }

}

// Drived class
public class MultipleInheritance {
public static void main(String[] args)
{
Child c = new Child();
c.print_One();
 c.print_Two();
c.print_One();
}
}

Advantages Of Inheritance in Java:

1. Code Reusability: Inheritance allows for code reuse and reduces the amount of code that
needs to be written. The subclass can reuse the properties and methods of the superclass,
reducing duplication of code.
2. Abstraction: Inheritance allows for the creation of abstract classes that define a common
interface for a group of related classes. This promotes abstraction and encapsulation, making
the code easier to maintain and extend.
3. Class Hierarchy: Inheritance allows for the creation of a class hierarchy, which can be used to
model real-world objects and their relationships.
4. Polymorphism: Inheritance allows for polymorphism, which is the ability of an object to take
on multiple forms. Subclasses can override the methods of the superclass, which allows them
to change their behavior in different ways.
Disadvantages of Inheritance in Java:
1. Complexity: Inheritance can make the code more complex and harder to understand. This is
especially true if the inheritance hierarchy is deep or if multiple inheritances is used.
2. Tight Coupling: Inheritance creates a tight coupling between the superclass and subclass,
making it difficult to make changes to the superclass without affecting the subclass.
Inheritance hierarchies
Super and subclasses
Self-assessment program
Create a base class containing the data members roll number and name. Also create a
member function to read and display the data using the concept of single level
inheritance. Create a derived class that contains marks of two subjects and total marks
as the data members

Memb er access rules

Access modifiers help to restrict the scope of a class, constructor, variable,
method, or data member. It provides security, accessibility, etc to the user
depending upon the access modifier used with the element.
Types of Access Modifiers in Java
There are four types of access modifiers available in Java:
1. Default – No keyword required
2. Private
3. Protected
4. Public

1. Default Access Modifier

When no access modifier is specified for a class, method, or data member – It is
said to be having the default access modifier by default. The data members,
classes, or methods that are not declared using any access modifiers i.e. having
default access modifiers are accessible only within the same package.
2. Private Access Modifier
The private access modifier is specified using the keyword private. The
methods or data members declared as private are accessible only within the
class in which they are declared.
• Any other class of the same package will not be able to access these
members.
• Top-level classes or interfaces can not be declared as private because
o private means “only visible within the enclosing class”.
o protected means “only visible within the enclosing class and any
subclasses”
3. Protected Access Modifier
• The protected access modifier is specified using the keyword protected.
• The methods or data members declared as protected are accessible within
the same package or subclasses in different packages.

4. Public Access modifier

The public access modifier is specified using the keyword public.
• The public access modifier has the widest scope among all other access
modifiers.
• Classes, methods, or data members that are declared as public
are accessible from everywhere in the program. There is no restriction
on the scope of public data members.

Important Points:
• If other programmers use your class, try to use the most restrictive access
level that makes sense for a particular member. Use private unless you
have a good reason not to.
 • Avoid public fields except for constants.

Super keyword : Super keyword in java is a reference variable that is used to

refer to parent class when working with objects.
Characteristics of Super Keyword in Java
In Java, super keyword is used to refer to the parent class of a subclass. Here are
some of its key characteristics:
• super is used to call a superclass constructor: When a subclass is
created, its constructor must call the constructor of its parent class. This is
done using the super() keyword, which calls the constructor of the parent
class.
• super is used to call a superclass method: A subclass can call a method
defined in its parent class using the super keyword. This is useful when
the subclass wants to invoke the parent class’s implementation of the
method in addition to its own.
• super is used to access a superclass field: A subclass can access a field
defined in its parent class using the super keyword. This is useful when
the subclass wants to reference the parent class’s version of a field.
• super must be the first statement in a constructor: When calling a
superclass constructor, the super() statement must be the first statement in
the constructor of the subclass.
 • super cannot be used in a static context: The super keyword cannot be
used in a static context, such as in a static method or a static variable
initializer.
• super is not required to call a superclass method: While it is possible
to use the super keyword to call a method in the parent class, it is not
required. If a method is not overridden in the subclass, then calling it
without the super keyword will invoke the parent class’s implementation.
Overall, the super keyword is a powerful tool for subclassing in Java, allowing
subclasses to inherit and build upon the functionality of their parent classes.
Use of super keyword in Java
It is majorly used in the following contexts as mentioned below:
• Use of super with Variables
• Use of super with Methods
• Use of super with Constructors
1. Use of super with Variables
This scenario occurs when a derived class and base class have the same data
members. In that case, there is a possibility of ambiguity r the JVM.

// super keyword in java example

// Base class vehicle

class Vehicle {
int maxSpeed = 120;
}

// sub class Car extending vehicle

class Car extends Vehicle {
int maxSpeed = 180;

void display()
{
// print maxSpeed of base class (vehicle)
System.out.println("Maximum Speed: "+ super.maxSpeed);
}
}
// Driver Program
class SuperTest {
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}

2. Use of super with Methods

This is used when we want to call the parent class method. So whenever a
parent and child class have the same-named methods then to resolve ambiguity
we use the super keyword.
// super keyword in java example
// superclass Person
class Person {
void message()
{
System.out.println("This is person class\n");
}
}
// Subclass Student
class Student extends Person {
void message()
{
System.out.println("This is student class");
}
// Note that display() is only in Student class
void display()
{
// will invoke or call current class message() method
message();

// will invoke or call parent class message() method

super.message();
}
}
class SuperMethodTest {
public static void main(String args[])
{
Student s = new Student();
 // calling display() of Student
s.display();
}
}

3. Use of super with constructors

The super keyword can also be used to access the parent class constructor. One
more important thing is that ‘super’ can call both parametric as well as non-
parametric constructors depending on the situation.
// Java Code to show use of
// super keyword with constructor

// superclass Person
class Person {
Person()
{
System.out.println("Person class Constructor");
}
}

// subclass Student extending the Person class

class Student extends Person {
Student()
{
// invoke or call parent class constructor
super();

System.out.println("Student class Constructor");

}
}

// Driver Program
class SuperConstructorTest {
public static void main(String[] args)
{
Student s = new Student();
}
}
Advantages of Using Java Super Keyword
The super keyword in Java provides many advantages in object-oriented
programming are as follows:
• Enables reuse of code: Using the super keyword allows subclasses to
inherit functionality from their parent classes, which promotes the reuse
of code and reduces duplication.
• Supports polymorphism: Because subclasses can override methods and
access fields from their parent classes using super, polymorphism is
possible. This allows for more flexible and extensible code.
• Provides access to parent class behaviour: Subclasses can access and
use methods and fields defined in their parent classes through the super
keyword, which allows them to take advantage of existing behaviour
without having to reimplement it.
• Allows for customization of behaviour: By overriding methods and
using super to call the parent implementation, subclasses can customize
and extend the behaviour of their parent classes.
• Facilitates abstraction and encapsulation: The use of super promotes
encapsulation and abstraction by allowing subclasses to focus on their
behaviour while relying on the parent class to handle lower-level details.

Preventing inheritance
There are 2 ways to stop or prevent inheritance in Java programming. By using
final keyword with a class or by using a private constructor in a class.
Problem Statement: Let’s say we have a class A and we don’t want to allow
any other class to be derived from it. What are the possible solutions?
Using final keyword before a class declaration we can stop a class to be
inherited by other classes. For example,
public final class A
{

}
If we try to extend the class A which is final, compiler will flash an error i.e.
“The Type B cannot the subclass the final Class A”, if class B is trying to
extend final class A.
public class B extends A{//Error :The Type B cannot the subclass the Final
Class A
}

We can also stop a class to be extended/inherited by other classes in Java by

making the class constructor private.
If we make the class constructor private we’ll not be able to create the object of
this class from outside of this class. But, our purpose is to just prevent a class to
be inherited and not to stop object creation. Hence, we need a method that can
create an object of this class and return it.

We need to put a static method that will create and return an object. Why Static
method? Because, from outside of a class, to call a normal method we need an
object of the class, but, as constructor is private, we cannot create an object,
hence, only solution is to have a static method that can be called using class
name.
So, as a solution to stop a class to be extended, we need to make a constructor
private and have one static method that will create an object of this class and
return it.
class A {
// Make constructor private to prevent object creation
//From outside of this class.
private A() {
}

//Static method to create and return an object.

//this method will be called from outside by using
//class name only.
 public static A GetInstance() {
return new A();
}
}
Final classes and methods
final is a keyword in java used for restricting some functionalities. We can
declare variables, methods, and classes with the final keyword.
Using final with inheritance
During inheritance, we must declare methods with the final keyword for which
we are required to follow the same implementation throughout all the derived
classes. Note that it is not necessary to declare final methods in the initial stage
of inheritance(base class always). We can declare a final method in any subclass
for which we want that if any other class extends this subclass, then it must
follow the same implementation of the method as in that subclass.

The object class and its methods

Object class is present in java.lang package. Every class in Java is directly or
indirectly derived from the Object class. If a class does not extend any other
class then it is a direct child class of Object and if extends another class then it
is indirectly derived. Therefore the Object class methods are available to all
Java classes. Hence Object class acts as a root of the inheritance hierarchy in
any Java Program.
Polymorphism
The word polymorphism means having many forms. In simple words, we can
define Java Polymorphism as the ability of a message to be displayed in more
than one form.
Real-life Illustration of Polymorphism in Java: A person at the same time can
have different characteristics. Like a man at the same time is a father, a husband,
and an employee. So the same person possesses different behaviors in different
situations. This is called polymorphism.
Types of Java Polymorphism
In Java Polymorphism is mainly divided into two types:
• Compile-time Polymorphism
• Runtime Polymorphism
Compile-Time Polymorphism in Java
It is also known as static polymorphism. This type of polymorphism is achieved
by function overloading or operator overloading.

Note: But Java doesn’t support the Operator Overloading.

Method Overloading
When there are multiple functions with the same name but different parameters
then these functions are said to be overloaded. Functions can be overloaded by
changes in the number of arguments or/and a change in the type of arguments.
class Helper {
// Method with 2 integer parameters
static int Multiply(int a, int b)
{
// Returns product of integer numbers
return a * b;
}
// Method 2 With same name but with 2 double parameters
static double Multiply(double a, double b)
{
// Returns product of double numbers
return a * b;
}
}
Runtime Polymorphism in Java
It is also known as Dynamic Method Dispatch. It is a process in which a
function call to the overridden method is resolved at Runtime. This type of
polymorphism is achieved by Method Overriding. Method overriding, on the
other hand, occurs when a derived class has a definition for one of the member
functions of the base class. That base function is said to be overridden.

Dynamic binding
Static vs Dynamic Binding in Java
• private, final and static members (methods and variables) use static
binding while for virtual methods (In Java methods are virtual by default)
binding is done during run time based upon the run time object.
• The static binding uses Type information for binding while Dynamic
binding uses Objects to resolve to bind.
 • Overloaded methods are resolved (deciding which method to be called
when there are multiple methods with the same name) using static
binding while overridden methods use dynamic binding, i.e, at run time.

Static Binding
The binding which can be resolved at compile time by the compiler is known as
static or early binding. The binding of all the static, private, and final methods is
done at compile-time.
// Java Program to Illustrate Static Binding

// Main class
class NewClass {

// Static nested inner class

// Class 1
public static class superclass {

// Method of inner class

static void print()
{

// Print statement
System.out.println(
"print() in superclass is called");
}
}

// Static nested inner class

// Class 2
public static class subclass extends superclass {

// Method of inner class

static void print()
{

// print statement
System.out.println(
"print() in subclass is called");
}
}
 // Method of main class
// Main driver method
public static void main(String[] args)
{

// Creating objects of static inner classes

// inside main() method
superclass A = new superclass();
superclass B = new subclass();

// Calling method over above objects

A.print();
B.print();
}
}

Output
print() in superclass is called
print() in superclass is called

Output Explanation: As you can see, in both cases the print method of the
superclass is called. Let us discuss how this happens
• We have created one object of subclass and one object of the superclass
with the reference of the superclass.
• Since the print method of the superclass is static, the compiler knows that
it will not be overridden in subclasses and hence compiler knows during
compile time which print method to call and hence no ambiguity.

Dynamic Binding
In Dynamic binding compiler doesn’t decide the method to be called.
Overriding is a perfect example of dynamic binding. In overriding both parent
and child classes have the same method.

// Java Program to Illustrate Dynamic Binding

// Main class
public class DynamicBinding {

// Static nested inner class

// Class 1
public static class superclass {

// Method of inner class 1

 void print()
{

// Print statement
System.out.println("print in superclass is called");
}
}

// Static nested inner class

// Class 2
public static class subclass extends superclass {

// Method of inner class 2

@Override void print()
{

// Print statement
System.out.println("print in subclass is called");
}
}

// Method inside main class

public static void main(String[] args)
{

// Creating object of inner class 1

// with reference to constructor of super class
superclass A = new superclass();

// Creating object of inner class 1

// with reference to constructor of sub class
superclass B = new subclass();

// Calling print() method over above objects

A.print();
B.print();
}
}

Output
print in superclass is called
print in subclass is called
Output Explanation:
• Methods are not static in this code.
• During compilation, the compiler has no idea as to which print has to be
called since the compiler goes only by referencing variable not by the
type of object, and therefore the binding would be delayed to runtime and
therefore the corresponding version of the print will be called based on
type on an object.

Static Binding Dynamic Binding

It takes place at compile time for which It takes place at runtime so do it is

is referred to as early binding referred to as late binding.

It uses overloading more precisely

It uses overriding methods.
operator overloading method

It takes place using virtual

It takes place using normal functions
functions

Static or const or private functions use

Real objects use dynamic binding
real objects in static binding

Method overriding
Overriding is a feature that allows a subclass or child class to provide a specific
implementation of a method that is already provided by one of its super-classes
or parent classes. When a method in a subclass has the same name, the same
parameters or signature, and the same return type(or sub-type) as a method in its
super-class, then the method in the subclass is said to override the method in the
super-class.
Method overriding is one of the ways by which Java achieves Run Time
Polymorphism. The version of a method that is executed will be determined by
the object that is used to invoke it. If an object of a parent class is used to
invoke the method, then the version in the parent class will be executed, but if
an object of the subclass is used to invoke the method, then the version in the
child class will be executed. In other words, it is 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.

// Java program to demonstrate method overriding in java

// Base Class
class Parent {
void show() { System.out.println("Parent's show()"); }
}

// Inherited class
class Child extends Parent {
// This method overrides show() of Parent
@Override void show()
{
System.out.println("Child's show()");
}
}

// Driver class
class Main {
 public static void main(String[] args)
{
// If a Parent type reference refers
// to a Parent object, then Parent's
// show is called
Parent obj1 = new Parent();
obj1.show();

// If a Parent type reference refers

// to a Child object Child's show()
// is called. This is called RUN TIME
// POLYMORPHISM.
Parent obj2 = new Child();
obj2.show();
}
}

Rules for Java Method Overriding

1. Overriding and Access Modifiers
2. Final methods can not be overridden
3. Static methods can not be overridden(Method Overriding vs Method
Hiding):
4. Private methods can not be overridden
5. The overriding method must have the same return type (or subtype)
6. Invoking overridden method from sub-class

Abstract classes and methods

Abstract class is declared with the abstract keyword. It may have both abstract
and non-abstract methods (methods with bodies). An abstract is a Java modifier
applicable for classes and methods in Java but not for Variables.

Java abstract class is a class that can not be initiated by itself, it needs to be
subclassed by another class to use its properties. An abstract class is declared
using the “abstract” keyword in its class definition.

Illustration of Abstract class

abstract class Shape
{
 int color;
// An abstract function
abstract void draw();
}

In Java, the following some important observations about abstract classes are as
follows:
1. An instance of an abstract class can not be created.
2. Constructors are allowed.
3. We can have an abstract class without any abstract method.
4. There can be a final method in abstract class but any abstract method in
class(abstract class) can not be declared as final or in simpler terms final
method can not be abstract itself as it will yield an error: “Illegal
combination of modifiers: abstract and final”
5. We can define static methods in an abstract class
6. We can use the abstract keyword for declaring top-level classes (Outer
class) as well as inner classes as abstract
7. If a class contains at least one abstract method then compulsory should
declare a class as abstract
8. If the Child class is unable to provide implementation to all abstract
methods of the Parent class then we should declare that Child class as
abstract so that the next level Child class should provide implementation
to the remaining abstract method

// Abstract class
abstract class Sunstar {
abstract void printInfo();
}

// Abstraction performed using extends

class Employee extends Sunstar {
void printInfo()
{
String name = "Raj";
int age = 24;
float salary = 5000.2F;
 System.out.println(name);
System.out.println(age);
System.out.println(salary);
}
}

// Base class
class Base {
public static void main(String args[])
{
Sunstar s = new Employee();
s.printInfo();
}
}

Abstract Class having constructor, data member, and methods

Elements abstract class can have
• data member
• abstract method
• method body (non-abstract method)
• constructor
• main() method.

// Java Program to implement Abstract Class

// having constructor, data member, and methods
import java.io.*;

abstract class Subject {

Subject() {
System.out.println("Learning Subject");
}

abstract void syllabus();

void Learn(){
System.out.println("Preparing Right Now!");
}
}

class IT extends Subject {

void syllabus(){
System.out.println("C , Java , C++");
}
}

class Abstract {
public static void main(String[] args) {
Subject x=new IT();

x.syllabus();
x.Learn();
}
}