1

MODULE 3

Class is a basis of OOP languages. It is a logical construct which defines shape and nature of an object.
Entire Java is built upon classes.

3.1 Inheritance
Inheritance is one of the building blocks of object oriented programming languages. It allows creation of
classes with hierarchical relationship among them. Using inheritance, one 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. 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 add its own, unique elements. Through inheritance, one can achieve re-usability of the
code.

In Java, inheritance is achieved using the keyword extends. The syntax is given below

class A //super class

{
//members of class A
}

class B extends A //sub class

{
//members of B
}

Dept of ISE, SCE

 2

Consider a program to understand the concept:

class A
{
int i, j;

void showij()
{
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A
{
int k;
void showk()
{
System.out.println("k: " + k);
}
void sum()
{
System.out.println("i+j+k: " + (i+j+k));
}
}

class SimpleInheritance
{
public static void main(String args[])
{
A superOb = new A();
B subOb = new B();
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();

subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();

System.out.println("Sum of i, j and k in subOb:");

subOb.sum();
}
}

Dept of ISE, SCE

 3

Note that, private members of the super class can not be accessed by the sub class. The subclass
contains all non-private members of the super class and also it contains its own set of members to
achieve specialization.

3.19.1 Type of Inheritance

 Single Inheritance: If a class is inherited from one parent class, then it is known as single
inheritance. This will be of the form as shown below –

superclass

subclass

The previous program is an example of single inheritance.

 Multilevel Inheritance: If several classes are inherited one after the other in a hierarchical
manner, it is known as multilevel inheritance, as shown below –

Dept of ISE, SCE

 4

3.19.2 A Superclass variable can reference a subclass object

A reference variable of a superclass can be assigned a reference to any subclass derived from that
superclass. Consider the following for illustration:

class Base
{
void dispB()
{
System.out.println("Super class " );
}
}
class Derived extends Base
{
void dispD()
{
System.out.println("Sub class ");
}
}

class Demo
{
public static void main(String args[])
{
Base b = new Base();
Derived d=new Derived();

b=d; //superclass reference is holding subclass object

b.dispB();
//b.dispD(); error!!
}
}

Note that, the type of reference variable decides the members that can be accessed, but not the type
of the actual object. That is, when a reference to a subclass object is assigned to a superclass
reference variable, you will have access only to those parts of the object defined by the superclass.

3.2 Using super

In Java, the keyword super can be used in following situations:
 To invoke superclass constructor within the subclass constructor
 To access superclass member (variable or method) when there is a duplicate member name in
the subclass

Let us discuss each of these situations:

 To invoke superclass constructor within the subclass constructor: Sometimes, we may
need to initialize the members of super class while creating subclass object. Writing such a code
in subclass constructor may lead to redundancy in code. For example,

class Box
{
double w, h, b;

Dept of ISE, SCE

 5

Box(double wd, double ht, double br)

{
w=wd; h=ht; b=br;
}
}
class ColourBox extends Box
{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
w=wd; h=ht; b=br; //code redundancy
colour=c;
}
}

Also, if the data members of super class are private, then we can’t even write such a code in subclass
constructor. If we use super() to call superclass constructor, then it must be the first statement
executed inside a subclass constructor as shown below –

class Box
{
double w, h, b;
Box(double wd, double ht, double br)
{
w=wd; h=ht; b=br;
}
}

class ColourBox extends Box

{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
super(wd, ht, br); //calls superclass constructor
colour=c;
}
}

class Demo
{
public static void main(String args[])
{
ColourBox b=new ColourBox(2,3,4, 5);
}
}

Here, we are creating the object b of the subclass ColourBox . So, the constructor of this class is
invoked. As the first statement within it is super(wd, ht, br), the constructor of superclass Box is
invoked, and then the rest of the statements in subclass constructor ColourBox are executed.

Dept of ISE, SCE

 6

 To access superclass member variable when there is a duplicate variable name in the
subclass: This form of super is most applicable to situations in which member names of a
subclass hide members by the same name in the superclass.

class A
{
int a;
}

class B extends A
{
int a; //duplicate variable a

B(int x, int y)
{
super.a=x; //accessing superclass a
a=y; //accessing own member a
}

void disp()
{
System.out.println("super class a: "+ super.a);
System.out.println("sub class a: "+ a);
}
}

class SuperDemo
{
public static void main(String args[])
{
B ob=new B(2,3);
ob.disp();
}
}

3.3 Creating Multilevel Hierarchy

Java supports multi-level inheritance. A sub class can access all the non-private members of all of its
super classes. Consider an illustration:

class A
{ int a;
}

class B extends A
{ int b;
}

class C extends B
{ int c;

Dept of ISE, SCE

 7

C(int x, int y, int z)

{
a=x; b=y; c=z;
}
void disp()
{
System.out.println("a= "+a+ " b= "+b+" c="+c);
}
}

class MultiLevel
{
public static void main(String args[])
{
C ob=new C(2,3,4);
ob.disp();
}
}

3.4 When Constructors are called

When class hierarchy is created (multilevel inheritance), the constructors are called in the order of their
derivation. That is, the top most super class constructor is called first, and then its immediate sub class
and so on. If super is not used in the sub class constructors, then the default constructor of super class
will be called.

class A
{
A()
{
System.out.println("A's constructor.");
}
}

class B extends A
{
B()
{
System.out.println("B's constructor.");
}
}
class C extends B
{
C()
{
System.out.println("C's constructor.");
}
}
class CallingCons
{
public static void main(String args[])

Dept of ISE, SCE

 8

{
C c = new C();
}
}

Output:
A's constructor
B's constructor
C's constructor

3.5 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.

class A
{
int i, j;
A(int a, int b)
{
i = a;
j = b;
}
void show() //suppressed
{
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;
}
void show() //Overridden method
{
System.out.println("k: " + k);
}
}
class Override
{
public static void main(String args[])
{
B subOb = new B(1, 2, 3);
subOb.show();
}
}

Dept of ISE, SCE

 9

Output:
k: 3

Note that, above program, only subclass method show() got called and hence only k got displayed. That
is, the show() method of super class is suppressed. If we want superclass method also to be called, we
can re-write the show() method in subclass as –

void show()
{
super.show(); // this calls A's show()
System.out.println("k: " + k);
}

Method overriding occurs only when the names and the type signatures of the two methods (one in
superclass and the other in subclass) are identical. If two methods (one in superclass and the other in
subclass) have same name, but different signature, then the two methods are simply overloaded.

3.6 Dynamic Method Dispatch

Method overriding forms the basis for one of Java’s most powerful concepts: dynamic method dispatch.
Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run
time, rather than compile time. Java implements run-time polymorphism using dynamic method dispatch.
We know that, a superclass reference variable can refer to subclass object. Using this fact, Java resolves
the calls to overridden methods during runtime. When an overridden method is called through a
superclass reference, Java determines which version of that method to execute based upon the type of
the object being referred to at the time the call occurs. Thus, this determination is made at run time.
When different types of objects are referred to, different versions of an overridden method will be called.
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. 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.

class A
{
void callme()
{
System.out.println("Inside A");
}
}
class B extends A
{
void callme()
{
System.out.println("Inside B");
}
}

class C extends A
{
void callme()
{

Dept of ISE, SCE

 10

System.out.println("Inside C");
}
}
class Dispatch
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();

A r; //Superclass reference
r = a; //holding subclass object
r.callme();
r = b;
r.callme();
r = c;
r.callme();
}
}

Why overridden methods?

Overridden methods are the way that Java implements the “one interface, multiple methods” aspect of
polymorphism. superclasses and subclasses form a hierarchy which moves from lesser to greater
specialization. Used correctly, the superclass provides all elements that a subclass can use directly. It
also defines those methods that the derived class must implement on its own. This allows the subclass
the flexibility to define its own methods, yet still enforces a consistent interface. Thus, by combining
inheritance with overridden methods, a superclass can define the general form of the methods that will be
used by all of its subclasses. Dynamic, run-time polymorphism is one of the most powerful mechanisms
that objectoriented design brings to bear on code reuse and robustness.

3.7 Using Abstract Classes

Sometimes, the method definition will not be having any meaning in superclass. Only the subclass
(specialization) may give proper meaning for such methods.In such a situation, having a definition for a
method in superclass is absurd. Also, we should enforce the subclass to override such a method. A
method which does not contain any definition in the superclass is termed as abstract method. Such a
method declaration should be preceded by the keyword abstract. These methods are sometimes
referred to as subclasser responsibility because they have no implementation specified in the superclass.

A class containing at least one abstract method is called as abstract class. Abstract classes can not be
instantiated, that is one cannot create an object of abstract class. Whereas, a reference can be created
for an abstract class.
abstract class A
{
abstract void callme();
void callmetoo()
{
System.out.println("This is a concrete method.");
}
}

Dept of ISE, SCE

 11

class B extends A
{
void callme() //overriding abstract method
{
System.out.println("B's implementation of callme.");
}
}

class AbstractDemo
{
public static void main(String args[])
{
B b = new B(); //subclass object
b.callme(); //calling abstract method
b.callmetoo(); //calling concrete method
}
}

Example: Write an abstract class shape, which has an abstract method area(). Derive three classes
Triangle, Rectangle and Circle from the shape class and to override area(). Implement run-time
polymorphism by creating array of references to supeclass. Compute area of different shapes and display
the same.

Solution:

abstract class Shape

{
final double PI= 3.1416;
abstract double area();
}

class Triangle extends Shape

{
int b, h;
Triangle(int x, int y) //constructor
{
b=x;
h=y;
}

double area() //method overriding

{
System.out.print("\nArea of Triangle is:");
return 0.5*b*h;
}
}

class Circle extends Shape

{
int r;

Dept of ISE, SCE

 12

Circle(int rad) //constructor

{
r=rad;
}

double area() //overriding

{
System.out.print("\nArea of Circle is:");
return PI*r*r;
}
}

class Rectangle extends Shape

{
int a, b;
Rectangle(int x, int y) //constructor
{
a=x;
b=y;
}
double area() //overriding
{
System.out.print("\nArea of Rectangle is:");
return a*b;
}
}

class AbstractDemo
{
public static void main(String args[])
{
Shape r[]={new Triangle(3,4), new Rectangle(5,6),new Circle(2)};

for(int i=0;i<3;i++)
System.out.println(r[i].area());
}
}

Output:
Area of Triangle is:6.0
Area of Rectangle is:30.0
Area of Circle is:12.5664

Note that, here we have created array r, which is reference to Shape class. But, every element in r is
holding objects of different subclasses. That is, r[0] holds Triangle class object, r[1] holds Rectangle class
object and so on. With the help of array initialization, we are achieving this, and also, we are calling
respective constructors. Later, we use a for-loop to invoke the method area() defined in each of these
classes.

Dept of ISE, SCE

 13

3.8 Using final

The keyword final can be used in three situations in Java:
 To create the equivalent of a named constant.
 To prevent method overriding
 To prevent Inheritance

To create the equivalent of a named constant: A variable can be declared as final. Doing so prevents
its contents from being modified. This means that you must initialize a final variable when it is declared.
For example:
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;

It is a common coding convention to choose all uppercase identifiers for final variables. Variables
declared as final do not occupy memory on a per-instance basis. Thus, a final variable is essentially a
constant.

To prevent method overriding: Sometimes, we do not want a superclass method to be overridden in

the subclass. Instead, the same superclass method definition has to be used by every subclass. In such
situation, we can prefix a method with the keyword final as shown below –
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!");
}
}

To prevent Inheritance: As we have discussed earlier, the subclass is treated as a specialized class
and superclass is most generalized class. During multi-level inheritance, the bottom most class will be
with all the features of real-time and hence it should not be inherited further. In such situations, we can
prevent a particular class from inheriting further, using the keyword final. For example –
final class A
{
// ...
}
class B extends A // ERROR! Can't subclass A
{
// ...
}

Dept of ISE, SCE

 14

Note:
 Declaring a class as final implicitly declares all of its methods as final, too.
 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

3.9 The Object Class

There is one special class, Object, defined by Java. All other classes are subclasses of Object. That is,
Object is a superclass of all other classes. This means that a reference variable of type Object can refer
to an object of any other class. Also, since arrays are implemented as classes, a variable of type Object
can also refer to any array. Object defines the following methods, which means that they are available in
every object.

Method Purpose

Object clone( ) Creates a new object that is the same as the object being cloned.

boolean equals(Object object) Determines whether one object is equal to another.

void finalize( ) Called before an unused object is recycled.

Class getClass( ) Obtains the class of an object at run time.

int hashCode( ) Returns the hash code associated with the invoking object.

void notify( ) Resumes execution of a thread waiting on the invoking object.

void notifyAll( ) Resumes execution of all threads waiting on the invoking object.

String toString( ) Returns a string that describes the object.

void wait( ) Waits on another thread of execution.

void wait(long milliseconds)
void wait(long milliseconds,
int nanoseconds)

The methods getClass( ), notify( ), notifyAll( ), and wait( ) are declared as final. You may override
the others. The equals( ) method compares the contents of two objects. It returns true if the objects
are equivalent, and false otherwise. The precise definition of equality can vary, depending on the
type of objects being compared. The toString( ) method returns a string that contains a description of
the object on which it is called. Also, this method is automatically called when an object is output
using println( ). Many classes override this method.

Dept of ISE, SCE

 15

Interfaces:
 A named collection of method declarations.
 A Java interface is a collection of constants and abstract methods
 Since all methods in an interface are abstract, the abstract modifier is usually left off
 Using interface, you can specify what a class must do, but not how it does.
 Interface fields are public, static and final by default, and methods are public and abstract.

Advantages of interfaces:
• It is used to achieve abstraction.
• By interface, we can support the functionality of multiple inheritances.

Syntax:
access_specifier interface interface_name
{
return-type method-name1(parameter-list);
return-type method-name2(parameter-list);
type final-varname1 = value;
type final-varname2 = value;
//...
return-type method-nameN(parameter-list);
type final-varnameN = value;
}

Implementing Interfaces
Once an interface has been defined, one or more classes can implement that interface. To implement an
interface, include the implements clause in a class definition, and then create the methods required by the
interface. The general form of a class that includes the implements clause looks like this:

Dept of ISE, SCE

 16

Default Interface Methods

A default method lets you define a default implementation for an interface method. In other words, by use of
a default method, it is possible for an interface method to provide a body, rather than being abstract.
During its development, the default method was also referred to as an extension method, and you will likely
see both terms used.

A primary motivation for the default method was to provide a means by which interfaces could be
expanded without breaking existing code.
Recall that there must be implementations for all methods defined by an interface. In the past, if a new
method were added to a popular, widely used interface, then the addition of that method would break
existing code because no implementation would be found for that new method.

The default method solves this problem by supplying an implementation that will be used if no other
implementation is explicitly provided. Thus, the addition of a default method will not cause preexisting code
to break.

Another motivation for the default method was the desire to specify methods in an interface that are,
essentially, optional, depending on how the interface is used. For example, an interface might define a
group of methods that act on a sequence of elements.
One of these methods might be called remove( ), and its purpose is to remove an element from the
sequence.

However, if the interface is intended to support both modifiable and nonmodifiable sequences, then
remove( ) is essentially optional because it won’t be used by nonmodifiable sequences. In the past, a class
that implemented a nonmodifiable sequence would have had to define an empty implementation of
remove( ), even though it was not needed.

Today, a default implementation for remove( ) can be specified in the interface that does nothing (or throws
an exception). Providing this default prevents a class used for nonmodifiable sequences from having to
define its own, placeholder version of remove( ). Thus, by providing a default, the interface makes the
implementation of remove( ) by a class optional.

Default Method Fundamentals

An interface default method is defined similar to the way a method is defined by a class. The primary
difference is that the declaration is preceded by the keyword default. For example, consider this simple
interface:

Dept of ISE, SCE

 17

for an implementing class to override it. In other words, if an implementing class does not provide its own
implementation, the default is used.

Use static Methods in an Interface

Another capability added to interface by JDK 8 is the ability to define one or more static methods. Like static
methods in a class, a static method defined by an interface can be called independently of any object.
Thus, no implementation of the interface is necessary, and no instance of the interface is required, in order
to call a static method. Instead, a static method is called by specifying the interface name, followed by a
period, followed by the method name.

Here is the general form: InterfaceName.staticMethodName

Notice that this is similar to the way that a static method in a class is called. The following shows an
example of a static method in an interface by adding one to MyIF, shown in the previous section. The static
method is getDefaultNumber( ). It returns zero.

Dept of ISE, SCE

 18

Private Interface Methods

A private interface method can be called only by a default method or another private method defined by the
same interface. Because a private interface method is specified private, it cannot be used by code outside
the interface in which it is defined.
This restriction includes subinterfaces because a private interface method is not inherited by a
subinterface. The key benefit of a private interface method is that it lets two or more default methods use a
common piece of code, thus avoiding code duplication. For example, here is another version of the
IntStack interface that has two default methods called popNElements( ) and skipAndPopNElements( ).
The first returns an array that contains the top N elements on the stack. The second skips a specified
number of elements and then returns an array that contains the next N elements. Both use a private
method called getElements( ) to obtain an array of the specified number of elements from the stack.

Dept of ISE, SCE

 19

Question Bank:

1. What is inheritance? Discuss different types of inheritance with suitable example.

2. Discuss the behavior of constructors when there is a multilevel inheritance. Give appropriate code
to illustrate the process.
3. Mention and explain the uses of super keyword in Java.
4. How do you pass arguments to superclass constructor through the subclass constructor? Explain
with a code snippet.
5. Discuss usage of final keyword in Java. Give suitable examples.
6. What do you mean by method overriding? Discuss with a programming example.
7. Explain abstract class and abstract method with suitable code snippet.
8. Write a note on:
a. Use of this keyword
b. Garbage Collection in Java
c. Finalize() method
d. Object Class
e. Dynamic Method Dispatch
9. Create an abstract class called Employee. Include the members: Name, EmpID and an abstract
method cal_sal(). Create two inherited classes SoftwareEng (with the members basic and DA)
and HardwareEng (with members basic and TA). Implement runtime polymorphism (dynamic
method dispatch) to display salary of different employees by creating array of references to
superclass.
10. Differentiate method overloading and method overriding.

Dept of ISE, SCE

 20

Dept of ISE, SCE