Inheritance in Java

Rajam Naidu
• In OOP another important feature is Reusability which is very
use full in two major issues of development :
• Saving Time

• Saving Memory

• In C++/Java the mechanism implements this reusability is

Inheritance.
INHERITANCE

• Deriving new classes from existing classes such that the new
classes acquire all the features of existing classes is called
inheritance.

• The class which inherits the properties of inherited is known as

superclass (base class, parent class). extends is the keyword
used to inherit the properties from one class to another class.
class SuperClass{

..................
..................
}
class SubClass extends SuperClass{
..................
..................
}
The advantage of Inheritance?

• In inheritance, a programmer reuses the super class code

without rewriting it, in creation of sub classes. So, developing
the classes becomes very easy. Hence, the programmer’s
productivity is increased.
// A simple example of inheritance. B subOb = new B();
// Create a superclass. // The superclass may be used by itself.
class A { int i, j; superOb.i = 10;
void showij() { superOb.j = 20;
System.out.println("i and j: " + i + " " + j); System.out.println("Contents of superOb: ");
} superOb.showij();
} System.out.println();
// Create a subclass by extending class A. /* The subclass has access to all public members of its
superclass. */
class B extends A {
subOb.i = 7;
int k;
subOb.j = 8;
void showk() {
subOb.k = 9;
System.out.println("k: " + k);
System.out.println("Contents of subOb: ");
}
subOb.showij();
void sum() {
subOb.showk();
System.out.println("i+j+k: " + (i+j+k));
System.out.println();
}
System.out.println("Sum of i, j and k in subOb:");
}
subOb.sum();
}
class SimpleInheritance {
}
public static void main(String args[]) {
A superOb = new A();
Forms of Inheritance:

• Single Inheritance: • Derivation of one class from two or more

super classes is called Multiple Inheritance
• Derivation a subclass from only one super
class is called Single Inheritance. • But java does not support Multiple Inheritance
directly. It can be implemented by using
• Hierarchical Inheritance: interface concept.
• Derivation of several classes from a single
• Hybrid Inheritance:
super class is called Hierarchical Inheritance:
• Derivation of a class involving more than one
• Multilevel Inheritance: from on Inheritance is called Hybrid
• Derivation of a classes from another derived Inheritance
classes called Multilevel Inheritance.

• Multiple Inheritance:
Defining a Subclass:

A subclass is defined as Syntax:

class Subclass-name extends Superclass-name

{
Variable declaration;

Method declaration;

}
Member access rules

• Even though a subclass includes all of the members of its super

class, it cannot access those members which are declared as
Private in super class.
• We can assign a reference of super class, in the object of sub
class. In that situation we can access only super class
members but not sub class members.
• This concept is called as
• ―Super class Reference in Sub class Object.
class A { }
int i; // public by default }
private int j; // private to A class Access {
void setij(int x, int y) { public static void main(String args[]) {
i = x; B subOb = new B();
j = y; subOb.setij(10, 12);
} subOb.sum();
} System.out.println("Total is " +
// A's j is not accessible here. subOb.total);
class B extends A { }
int total; }
void sum() {
total = i + j; // ERROR, j is not accessible
here
• Super class variables can be referred in sub-class object
• A reference variable of a super class can be assigned a
reference to any subclass derived from that super class.
• When a reference to a subclass object is assigned to a super
class reference variable, we will have to access only to those
parts of the object defined by the super class. It is because the
super class has no knowledge about what a sub class adds to
it.
Using Final keyword:

We can use final key word in three ways:

• Used to create equivalent of a named constant
• Final datatype identifier = ………..;
• Used to prevent inheritance
• Final class …………..
• Used to avoid overloading
• Final return type ………….
Using final to Prevent Overriding:

• While method overriding is one of Java’s most powerful features,

there will be times when you will want to prevent it from occurring.

• To disallow a method from being overridden, specify final as a

modifier at the start of its declaration.

• Methods declared as final cannot be overridden.

• The following fragment illustrates final:

Using final to Prevent Inheritance:

• Sometimes you will want to prevent a class from being

inherited. To do this, precede the class declaration with final.
Declaring a class as final implicitly declares all of its methods
as final, too. As you might expect, it is illegal to declare a class
as both abstract and final since an abstract class is incomplete
by itself and relies upon its subclasses to provide complete
implementations.
class A {
final void meth() {
System.out.println("This is a final method.");
}
}
class B extends A {
void meth() { // ERROR! Can't override.
System.out.println("Illegal!");
}
}
Example of a final class:
final class A {
// ...
}
// The following class is illegal.
class B extends A { // ERROR! Can't subclass A
// ...
}
Polymorphism Method overriding:

• In a class hierarchy, when a method in a sub class has the same

name and type signature as a method in its super class, then
the method in the sub class is said to override the method in the
super class.

• When an overridden method is called from within a sub class, it

will always refer to the version of that method defined by the
sub class.
Dynamic method dispatch

• It is a mechanism by which a call to an overridden method is

resolved at run time rather then compile time.

• It is important because this is how java implements runtime

polymorphism.

• Before going to that we must know about super class reference

sub class object.
Abstract class: -1

• An abstract method is a method that is declared with only its

signatures with out implementations.

• An abstract class is class that has at least one abstract

method.

• We can’t declare any abstract constructor.

• Abstract class should not include any abstract static method.

Abstract class : -2
• Abstract class can’t be directly instantiated with the new
operator.
• Any sub class of abstract class must be either implements all
the abstract methods in the
• super class or declared it self as abstract.
• Abstract modifier referred as ―subclass responsibilities,
because of no implementation of methods. Thus, a sub class
must override them.
Abstract class Syntax:
The syntax is:
Abstract class class-name
{
Variables
Abstract methods;
Concrete methods;
.
.
.}
The ‘super’ Keyword:

• If we create an object to super class, we can access only the super

class members, but not the sub class members. But if we create sub
class object, all the members of both super and sub classes are
available to it. This is the reason; we always create an object to sub
class in inheritance. Sometimes, the super class members and sub
class members may have same names. In that case, by default only
sub class members are accessible.
• super can be used to refer super class variables, as:
• super.variableName
• super can be used to refer super class methods, as:
• super.methodName()
• super can be used to refer super class constructor.
• Default constructor of the super class, is available by default
• to sub class.
• To call parameterized constructor, we can write:
• super(values)
final keyword:
• The final keyword in java is used to restrict the user. The java final
keyword can be used in many contexts. 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.
Single Inheritance
Single Inheritance
The class inherited from
Sub-class3 Super class.

Single Inheritance Single Inheritance

This class is inherited This class inherited from
from Super class. Super Super class
Class

Sub-class1 Sub-class2

Your logo