20

Object Oriented Programming with Java(BCS306A)

MODULE-3 (Chapter-3 Contd..)

3.19 Inheritance
Java, Inheritance is an important pillar of OOP(Object-Oriented Programming).
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 addition, you can add new fields and methods to your current class as well.
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.
Important 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 derived-class extends base-class
{
//methods and fields
}

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:

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 21
Object Oriented Programming with Java(BCS306A)

class A //super class

{
//members of class A
}

class B extends A //sub class

{
//members of B
}

Consider a program to understand the concept:

class A
{
int i, j;

void showij()
{
[Link]("i and j: " + i + " " + j);
}
}

class B extends A
{
int k;
void showk()
{
[Link]("k: " + k);
}
void sum()
{
[Link]("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;
[Link]("Contents of superOb: ");
[Link]();

subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
[Link]("Contents of subOb: ");

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 22
Object Oriented Programming with Java(BCS306A)

[Link]();
[Link]();

[Link]("Sum of i, j and k in subOb:");

[Link]();
}
}

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 –

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 23
Object Oriented Programming with Java(BCS306A)

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()
{
[Link]("Super class " );
}
}
class Derived extends Base
{
void dispD()
{
[Link]("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

[Link]();
//[Link](); 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.20 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;

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 24
Object Oriented Programming with Java(BCS306A)

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.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 25
Object Oriented Programming with Java(BCS306A)

 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()
{
[Link]("super class a: "+ super.a);
[Link]("sub class a: "+ a);
}
}

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

3.21 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;

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 26
Object Oriented Programming with Java(BCS306A)

C(int x, int y, int z)

{
a=x; b=y; c=z;
}
void disp()
{
[Link]("a= "+a+ " b= "+b+" c="+c);
}
}

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

3.22 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()
{
[Link]("A's constructor.");
}
}

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

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 27
Object Oriented Programming with Java(BCS306A)

{
C c = new C();
}
}

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

3.23 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
{
[Link]("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
{
[Link]("k: " + k);
}
}
class Override
{
public static void main(String args[])
{
B subOb = new B(1, 2, 3);
[Link]();
}
}

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 28
Object Oriented Programming with Java(BCS306A)

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()
{
[Link](); // this calls A's show()
[Link]("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.24 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()
{
[Link]("Inside A");
}
}
class B extends A
{
void callme()
{
[Link]("Inside B");
}
}

class C extends A
{
void callme()
{

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 29
Object Oriented Programming with Java(BCS306A)

[Link]("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
[Link]();
r = b;
[Link]();
r = c;
[Link]();
}
}

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.25 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 [Link] 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()
{
[Link]("This is a concrete method.");
}
}

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 30
Object Oriented Programming with Java(BCS306A)

class B extends A
{
void callme() //overriding abstract method
{
[Link]("B's implementation of callme.");
}
}

class AbstractDemo
{
public static void main(String args[])
{
B b = new B(); //subclass object
[Link](); //calling abstract method
[Link](); //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

{
[Link]("\nArea of Triangle is:");
return 0.5*b*h;
}
}

class Circle extends Shape

{
int r;

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 31
Object Oriented Programming with Java(BCS306A)

Circle(int rad) //constructor

{
r=rad;
}

double area() //overriding

{
[Link]("\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
{
[Link]("\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++)
[Link](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.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 32
Object Oriented Programming with Java(BCS306A)

3.26 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()
{
[Link]("This is a final method.");
}
}
class B extends A
{
void meth() // ERROR! Can't override.
{
[Link]("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: [Link], Associate Professor, SDM Institute of Technology, Ujire

 33
Object Oriented Programming with Java(BCS306A)

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

Question Bank:
1. Define class. Give syntax and example.
2. Briefly explain static members of the class with suitable examples.
3. Discuss method overloading. Write a program to overload a method area() to compute area of a
triangle and a circle.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 34
Object Oriented Programming with Java(BCS306A)

4. Define a constructor. What are the salient features of Constructor? Write a Java program to show
these features.
5. How do you overload a constructor? Explain with a program.
6. Define recursion. Write a recursive program to find nth Fibonacci number.
7. Write a program to implement stack operations.
8. What are different parameter passing techniques in Java? Discuss the salient features of the
same.
9. What are various access specifiers in Java? List out the behaviour of each of them.
10. Create a Java class called Student with the following details as variables (USN, Name, Branch,
Phone Number). Write a Java program to create n student objects and print USN, Name, Branch,
and Phone number with suitable heading.
11. What is inheritance? Discuss different types of inheritance with suitable example.
12. Discuss the behavior of constructors when there is a multilevel inheritance. Give appropriate code
to illustrate the process.
13. Mention and explain the uses of super keyword in Java.
14. How do you pass arguments to superclass constructor through the subclass constructor? Explain
with a code snippet.
15. Discuss usage of final keyword in Java. Give suitable examples.
16. What do you mean by method overriding? Discuss with a programming example.
17. Explain abstract class and abstract method with suitable code snippet.
18. Write a note on:
a. Use of this keyword
b. Garbage Collection in Java
c. Finalize() method
d. Object Class
e. Dynamic Method Dispatch
19. 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.
20. Differentiate method overloading and method overriding.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 35
Object Oriented Programming with Java(BCS306A)

3.3 JAVA Interface

Java Interface Default Method
For creating a default method in java interface,
we need to use “default” keyword with the method signature.
For example,
package [Link];

public interface Interface1 {

void method1(String str);

default void log(String str){

[Link]("I1 logging::"+str);
}
}

Interface is an abstract type that can contain only the declarations of methods and constants. 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.

3.3.1 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);
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.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 5
Object Oriented Programming with Java(BCS306A)

3.3.2 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
{
[Link]("callback called with " + p);
}
void test()
{
[Link](“ordinary method”);
}
}

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

// [Link]() //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 –

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 Object Oriented Programming with Java(BCS306A)

interface ICallback
{
void callback(int param);
}

class Client implements ICallback

{
public void callback(int p) //note public
{
[Link]("callback called with " + p);
}
}

class Client2 implements ICallback

{
public void callback(int p)
{
[Link]("Another version of ICallBack");
[Link]("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

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.

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 7
Object Oriented Programming with Java(BCS306A)

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.

3.3.3 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()
{
if(mr<40)
return FAIL;
else return PASS;
}
}
class Exam extends Result implements SharedConst
{
Exam(double m)
{
super(m);
}

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 8
Object Oriented Programming with Java(BCS306A)

public static void main(String args[])

{
Exam r = new Exam(56);

switch([Link]())
{
case FAIL:
[Link]("Fail");
break;
case PASS:
[Link]("Pass");
break;
}
}
}

3.3.4 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()
{
[Link]("Implement meth1().");
}

public void meth2()

{
[Link]("Implement meth2().");
}
public void meth3()
{
[Link]("Implement meth3().");
}
}

By: [Link], Associate Professor, SDM Institute of Technology, Ujire

 9
Object Oriented Programming with Java(BCS306A)

class IFExtend
{
public static void main(String arg[])
{
MyClass ob = new MyClass();
ob.meth1();
ob.meth2();
ob.meth3();
}
}
Answer the following
1. What is interface in JAVA? Explain with example
2. Explain default interface method with suitable example
3. How static methods can be used in interface? Explain with suitable example
4. What is Private interface methods? Explain

Static Methods in Interface are those methods, which are defined

in the interface with the keyword static. Unlike other methods in
Interface, these static methods contain the complete definition
of the function and since the definition is complete and the
method is static, therefore these methods cannot be
overridden or changed in the implementation class.
// Java program to demonstrate
// static method in Interface.

interface NewInterface {

// static method
static void hello()
{
[Link]("Hello, New Static Method Here");
}

// Public and abstract method of Interface

void overrideMethod(String str);
}

// Implementation Class
public class InterfaceDemo implements NewInterface {

public static void main(String[] args)

{
InterfaceDemo interfaceDemo = new InterfaceDemo();

// Calling the static method of interface

[Link]();

// Calling the abstract method of interface

[Link]("Hello, Override Method here");
}

// Implementing interface method

@Override
public void overrideMethod(String str)
{
[Link](str);
}
}
Output:
Hello, New Static Method Here
Hello, Override Method here

By: [Link], Associate Professor, SDM Institute of Technology, Ujire