Object Oriented Programming with JAVA BCS306A 1

Module-3

Inheritance
Inheritance is one of the building blocks of object oriented programming languages. 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. In the terminology of Java, a class that is
inherited is called a super class. The class that does the inheriting is called a subclass. Therefore, a
sub class 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 //subclass

{
//members of B
}

Consider a program to understand the concept:

Class A
{
int i,j;

void showij()
{
System.out.println("iandj:"+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));
}
}

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 2

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("ContentsofsuperOb:");
superOb.showij();

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

System.out.println("Sumofi,jandkinsubOb:"); subOb.sum();
}
}

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.

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 – For example program refer multi
level hierarchy program

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
 Object Oriented Programming with JAVA BCS306A 3

• Hierarchical Inheritance
In Hierarchical Inheritance, one class serves as a superclass (base class) for more than one subclass. In
the below image, class A serves as a base class for the derived classes B, C, and D.

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 4

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

• Hybrid Inheritance
Hybrid means consist of more than one. Hybrid inheritance is the combination of two or more
types of inheritance.

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 5

A Super class variable can reference a sub class object

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

Class Base
{
void dispB()
{
System.out.println("Superclass");
}
}
Class Derived extends Base
{
void dispD()
{
System.out.println("Subclass");
}
}

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.

Using super
In Java,the keyword super can be used in following situations:
• To invoke super class constructor within the sub class constructor
• To access superclass member (variable or method) when there is a duplicate member name in
the subclass(both super and sub class member names are same).

Let us discuss each of these situations:

• To invoke superclass constructor within the subclass constructor: Some times, 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;

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 6

Box(doublewd,doubleht,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); //callssuperclassconstructor
colour=c;
}
}

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

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 7

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.
• 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 variablea

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

Void disp()
{
System.out.println("superclassa:"+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();
}
}

Creating Multi level 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;

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 8

Class C extends B
{ int c;

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();
}
}

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 soon. 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'sconstructor.");
}
}

Class B extends A
{
B()
{
System.out.println("B'sconstructor.");
}
}
Class C extends B
{
C() {

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 9

}
} System.out.println("C'sconstructor.");
Class CallingCons
{
Public static void main(String args[])
{
C c = new C();
}
}

Output:
A'sconstructor
B'sconstructor
C'sconstructor

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 10

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("iandj:"+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();
}
}

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 11

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 –

voidshow()
{
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.

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 containsa 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("InsideA");
}
}
Class B extends A
{
void callme()
{
System.out.println("InsideB");
}
}

Class C extends A
{
Void callme()
{

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 12

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

A r; //Super class reference

r=a; //holding sub class 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 object oriented design brings to bear on code reuse and robustness.

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 some times
referred to as subclass 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 cannot be
instantiated, that is one cannot create an object of abstract class. Where as, a reference can be created
for an abstract class.
Abstract class A
{
Abstract void callme();
void callmetoo()
{
System.out.println("Thisisaconcretemethod.");
}
}

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 13

Class B extends A
{
Void callme()//overriding abstract method
{
System.out.println("B'simplementationofcallme.");
}
}

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("\nAreaofTriangleis:");
return 0.5*b*h;
}
}

Class Circle extends Shape

{
int r;

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 14

Circle(int rad) //constructor

{
r=rad;
}

Double area() //overriding

{
System.out.print("\nAreaofCircleis:");
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("\nAreaofRectangleis:");
return a*b;
}
}

Class AbstractDemo
{
Public static void main(String args[])
{
Shaper[]={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
AreaofRectangleis: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.

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 15

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;
finalintFILE_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("Thisisafinalmethod.");
}
}
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
{
// ...
}

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 16

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

Local Variable Type Inference

Inference refers to the automatic detection of the datatype of a variable,done generally at the time of
compilation.
Local variable type inference is one of the most evident change to language available from java 10
onwards.It allows to define a variable using var and without specifying the type of it.The compiler infers the
type of the variable using the value provided.This type inference is restricted to lacal variables.

Old way of declaring local variable

String name-“welcome to city engineering college”;

New way of declaring local variable

Var name=” welcome to city engineering college”;

✓ No type inference in case of member variable,method parameters,return values.

✓ Local variable should be initialized at time of declaration otherwise compiler will not be infer and
will throw error
✓ Local variable inference is available inside initialization block of loop statements.

import java.util.List;
public class Tester {
public static void main(String[] args) {
var names = List.of("Julie", "Robert", "Chris", "Joseph");
for (var name : names) {
System.out.println(name);
}
System.out.println("");
for (var i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
}}

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.

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 17

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

int hashCode() Returns the hashcode 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.

Interfaces
Interface is an abstract type that can contain only the declarations of methods and constants(By default
public abstract methods and Final static variables). Interfaces are syntactically similar to classes, but they
do not contain instance variables, and their methods are declared without any body. Any number of
classes can implement an interface. One class may implement many interfaces. By providing the
interface keyword, Java allows you to fully utilize the “one interface, multiple methods” aspect of
polymorphism. Interfaces are alternative means for multiple inheritance in Java.

Defining an Interface
An interface is defined much like a class. This is the general form of an interface:

access interface name

{
type final-varname1 = value;
type final-varname2 = value;
…………………
return-type method-name1(parameter-list);

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 18

return-type method-name2(parameter-list);
…………………
}

Few key-points about interface:

• When no access specifier is mentioned for an interface, then it is treated as default and the
interface is only available to other members of the package in which it is declared. When an
interface is declared as public, the interface can be used by any other code.
• All the methods declared are abstract methods and hence are not defined inside interface. But, a
class implementing an interface should define all the methods declared inside the interface.
• Variables declared inside of interface are implicitly final and static, meaning they cannot be
changed by the implementing class.
• All the variables declared inside the interface must be initialized.
• All methods and variables are implicitly public.
Implementing Interface
To implement an interface, include the implements clause in a class definition, and then create the
methods defined by the interface. The general form of a class that includes the implements clause looks
like this:

class classname extends superclass implements interface1, interface2...

{
// class-body
}

Consider the following example:

interface ICallback
{
void callback(int param);
}

class Client implements ICallback

{
public void callback(int p) //note public
{
System.out.println("callback called with " + p);
}
void test()
{
System.out.println(“ordinary method”);
}
}

class TestIface
{
public static void main(String args[])
{
ICallback c = new Client();
c.callback(42);

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 19

// c.test() //error!!
}
}

Here, the interface ICallback contains declaration of one method callback(). The class Client
implementing this interface is defining the method declared in interface. Note that, the method callback()
is public by default inside the interface. But, the keyword public must be used while defining it inside the
class. Also, the class has its own method test(). In the main() method, we are creating a reference of
interface pointing to object of Client class. Through this reference, we can call interface method, but not
method of the class.

The true polymorphic nature of interfaces can be found from the following example –
interface ICallback
{
void callback(int param);
}

class Client implements ICallback

{
public void callback(int p) //note public
{
System.out.println("callback called with " + p);
}
}

class Client2 implements ICallback

{
public void callback(int p)
{
System.out.println("Another version of ICallBack");
System.out.println("p squared " + p*p);
}
}

class TestIface
{
public static void main(String args[])
{
ICallback x[]={new Client(), new Client2()};

for(int i=0;i<2;i++)
x[i].callback(5);
}
}

Output:
callback called with 5
Another version of ICallBack
p squared 25

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 20

In this program, we have created array of references to interface, but they are initialized to class objects.
Using the array index, we call respective implementation of callback() method.

Note: Interfaces may look similar to abstract classes. But, there are lot of differences between them as
shown in the following table:
Abstract Class Interface
Can have instance methods that implements Are implicitly abstract and cannot have
a default behavior. implementations.

May contain non-final variables. Variables declared in interface are by

default final.

Can have the members with private, Members of a Java interface are public by
protected, etc.. default.

A Java abstract class should be extended Java interface should be implemented

using keyword “extends”. using keyword “implements”
An abstract class can extend another Java An interface can extend another Java
class and implement multiple Java interface only.
interfaces.

Not slow Compared to abstract classes, interfaces

are slow as it requires extra indirection.

Variables in Interfaces
You can use interfaces to import shared constants into multiple classes by simply declaring an interface
that contains variables that are initialized to the desired values. When you include that interface in a class
all of those variable names will be in scope as constants (Similar to #define in C/C++). If an interface
contains no methods, then any class that includes such an interface doesn’t actually implement anything.
It is just using a set of constants. Consider an example to illustrate the same:

interface SharedConst
{
int FAIL=0; //these are final by default
int PASS=1;
}

class Result implements SharedConst

{
double mr;

Result(double m)
{
mr=m;
}

int res()
{

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 21

if(mr<40)
return FAIL;
else return PASS;
}
}
class Exam extends Result implements SharedConst
{
Exam(double m)
{
super(m);
}
public static void main(String args[])
{
Exam r = new Exam(56);

switch(r.res())
{
case FAIL:
System.out.println("Fail");
break;
case PASS:
System.out.println("Pass");
break;
}
}
}

Interfaces can be extended

One interface can inherit another interface by using the keyword extends. The syntax is the same as for
inheriting classes. When a class implements an interface that inherits another interface, it must provide
implementations for all methods defined within the interface inheritance chain.

interface A
{
void meth1();
void meth2();
}

interface B extends A
{
void meth3();
}

class MyClass implements B

{
public void meth1()
{
System.out.println("Implement meth1().");
}

public void meth2()

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 22

{
System.out.println("Implement meth2().");
}
public void meth3()
{
System.out.println("Implement meth3().");
}
}
class IFExtend
{
public static void main(String arg[])
{
MyClass ob = new MyClass();
ob.meth1();
ob.meth2();
ob.meth3();
}
}

Default interface Methods

Before java 8,interfaces could have only abstract methods.The implementation of these methods has
to be provided in a separate class.So,if a new method is to be added in an interface,then its
implementation code has to be provided in the class implementing the same interface.To overcome
this issue,java 8 has introduced the concept of default methods which allow the interfaces to have
methods with implementation without affecting the classes that implement the interface.

Purpose of default method in interface

The most important use of default methods in interfaces is to provide additional functionality to a
given type without breaking down the implementing classes.Before java 8,if a new method was
introduced in an interface than all the implementing classes used to break.

interface TestInterface

Public void square(int a);

Default void show()

System.out.println(“Default method Executed”);

Class TestClass implements TestInterface

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 23

Public void square(int a)

System.out.println(a*a);

Public static void main(String args [ ])

TestClass d = new TestClass();

d.square(4);

d.show(); //default method executed

Use static Methods in an interface

The interface can have static methods as well which is similar to static method of classes. java 8 has
introduced the concept of Static Methods. Java interface static methods are good for providing utility
methods.A static methods of interface cannot be overridden,and static method should be called
through interface name.

interface TestInterface

Public void square(int a); //abstract method

static void show() //static method

System.out.println(“static method Executed”);

Class TestClass implements TestInterface

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 24

Public void square(int a)

System.out.println(a*a);

Public static void main(String args [ ])

TestClass d = new TestClass();

d.square(4);

TestInterface.show(); //static method executed

Private Interface Methods

In java 9,we can create private methods inside an interface.Interface allows us to declare private
methods that help to share common code between non-abstract methods.before java 9,creating
private methods inside an interface cause a compile time error.

To write sensitive code which would not want to be accessed by any class or interface

Interface sayable

Default void say()

saySomething(); //calling private method

sayPolitely(); //calling private static method

Private void saySomething()

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 25

System.out.println(“Hello…I am private method”);

Private static void sayPolitely()

System.out.println(“I am private static method”);

Public class privateInterface implements sayable

Public static void main(String args [ ])

Sayable s = new privateInterface();

s.say();

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC
Object Oriented Programming with JAVA BCS306A 26

By: Mr.Gangappa D and Mrs.Shruthi Vijay Assistant Professors, Dept of CSE, CEC