Open In App

Extends vs Implements in Java

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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. There are two main keywords,

“extends”

and

“implements”

which are used in Java for inheritance. In this article, the difference between extends and implements is discussed. Before getting into the differences, lets first understand in what scenarios each of the keywords are used.

Extends:

In Java, the

extends

keyword is used to indicate that the

class

which is being defined is derived from the base class using inheritance. So basically, extends keyword is used to extend the functionality of the parent class to the subclass. In Java, multiple inheritances are not allowed due to ambiguity. Therefore, a class can extend only one class to avoid ambiguity.

Example:

Java




class One {
    public void methodOne()
    {
 
        // Some Functionality
    }
}
 
class Two extends One {
 
    public static void main(String args[])
    {
        Two t = new Two();
 
        // Calls the method one
        // of the above class
        t.methodOne();
    }
}


Implements:

In Java, the

implements

keyword is used to implement an

interface

. An interface is a special type of class which implements a complete abstraction and only contains

abstract methods

. To access the interface methods, the interface must be “implemented” by another class with the implements keyword and the methods need to be implemented in the class which is inheriting the properties of the interface. Since an interface is not having the implementation of the methods, a class can implement any number of interfaces at a time.

Example

Java




// Defining an interface
interface One {
    public void methodOne();
}
 
// Defining the second interface
interface Two {
    public void methodTwo();
}
 
// Implementing the two interfaces
class Three implements One, Two {
    public void methodOne()
    {
 
        // Implementation of the method
    }
 
    public void methodTwo()
    {
 
        // Implementation of the method
    }
}


Note:

A class can extend a class and can implement any number of interfaces simultaneously.

Example

Java




// Defining the interface
interface One {
 
    // Abstract method
    void methodOne();
}
 
// Defining a class
class Two {
 
    // Defining a method
    public void methodTwo()
    {
    }
}
 
// Class which extends the class Two
// and implements the interface One
class Three extends Two implements One {
 
    public void methodOne()
    {
 
        // Implementation of the method
    }
}


Note:

An interface can extend any number of interfaces at a time.

Example:

Java




// Defining the interface One
interface One {
    void methodOne();
}
 
// Defining the interface Two
interface Two {
    void methodTwo();
}
 
// Interface extending both the
// defined interfaces
interface Three extends One, Two {
}


The following table explains the difference between the extends and interface:

S.No. Extends Implements
1. By using “extends” keyword a class can inherit another class, or an interface can inherit other interfaces By using “implements” keyword a class can implement an interface
2. It is not compulsory that subclass that extends a superclass override all the methods in a superclass. It is compulsory that class implementing an interface has to implement all the methods of that interface.
3. Only one superclass can be extended by a class. A class can implement any number of an interface at a time
4. Any number of interfaces can be extended by interface. An interface can never implement any other interface


Last Updated : 01 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads