How to Implement Interface in Java?

How to Implement Interface in Java? Adding an implement clause to the class declaration allows you to declare a class that complies with an interface.

A list of the interfaces that your class implements, separated by commas, comes after the keyword implements since your class may implement more than one interface.

What is an interface in Java?

An interface is a completely “abstract class” that is used to group functions with empty bodies that do similar things.


// interface in Java

interface Cat {

  public void carSound(); // interface method (does not have a body)

  public void run(); // interface default method (does not have a body)


To gain access to the interface’s methods, another class must “implement” the interface by using the implements keyword (instead of the extends keyword).

This is analogous to inheriting the interface’s functionality.

The “implement” class is in charge of providing the body of the abstract method defined, which is often called the “implementation.”


// Interface
interface Car {

  public void carSound(); // interface method (does not have a body)

  public void start(); // interface method (does not have a body)


// BMW "implements" the Car interface

class BMW implements Car {

  public void carSound() {

    // The body of carSound() is provided here

    System.out.println("Brooommm  Brooommm broooommmmm");


  public void start() {

    // The body of sleep() is provided here

    System.out.println("Start engine");



public class Main {

  public static void main(String[] args) {

        BMW myCar = new BMW();  






Start engine
Brooommm  Brooommm broooommmmm

In order for you to test the Java code provided in this lesson, you must test the code in your code editor.

But if you wish to run this code online, we also have an online compiler in Java for you to test your Java code for free.

You can test the above example here! ➡Java Online Compiler 

How to declare an Interface in Java?

The interface keyword is used to declare an interface. It is applied to offer complete abstraction.

This means that by default, all fields in an interface are public, static methods, and final and that all methods in an interface are declared with an empty body.

Example of an interface in Java

Let us look at a Java Interface example that is more useful.

// program created by Glenn

// To use the sqrt function

interface  Polygon {

   void getArea();


 // calculate the perimeter of a Polygon

   default void getPerimeter(int... sides) {

      int perimeter = 0;

      for (int side: sides) {

         perimeter += side;


   System.out.println("Perimeter: " + perimeter);



class Triangle implements Polygon {

   private int a, b, c;

   private double s, area;

// initializing sides of a triangle

   Triangle(int a, int b, int c) {

      this.a = a;

      this.b = b;

      this.c = c;

      s = 0;


// calculate the area of a triangle

   public void getArea() {

      s = (double) (a + b + c)/2;

      area = Math.sqrt(s*(s-a)*(s-b)*(s-c));

      System.out.println("Area: " + area);



public class Main {

   public static void main(String[] args) {

      Triangle t1 = new Triangle(6, 5, 7);

// calls the method of the Triangle class


// calls the method of Polygon

      t1.getPerimeter(6, 5, 7);



Implementation of interfaces

To declare a class that uses an interface, add a “implements” clause.

Your class can implement more than one interface, so the word implement is followed by a comma-separated list.

What is the use of the interface in Java?

In Java, an interface provides an abstract type that describes how a class should act.

This technology supports abstraction, polymorphism, and multiple inheritance, which are all core concepts of Java.

In Java, abstraction is done using interfaces.

What is the use of interface in Java
What is the use of interface in Java

Extending multiple interfaces

There is only one parent class that a Java class can extend. There is a restriction to implement multiple interfaces.

As opposed to classes, interfaces can extend several parent interfaces and are not considered to be classes.

A comma separates the list of parent interfaces from the extends keyword, which is only used once.

Extending interfaces

A class can extend another class in the same way that an interface can extend another interface.

The extends keyword is used to add to an interface, and the methods of the parent interface are passed on to the child interface.


// Filename:

public interface Sports {

   public void setHomeTeam(String name);

   public void setVisitingTeam(String name);


// Filename:

public interface Basketball extends Sports {

   public void homeShotScored(int points);

   public void visitingShotScored(int points);

   public void endOfQuarter(int quarter);


// Filename:

public interface SepakTakraw extends Sports {

   public void homeKickScored();

   public void visitingKickScored();

   public void endOfPeriod(int period);

   public void overtimePeriod(int ot);


The Sepak Takraw interface has four methods, but it gets two from Sports.

This means that a class that implements Sepak Takraw must implement all six methods.

In the same way, a class that implements Basketball needs to define the three Basketball methods and the two Sports methods.

Advantages of the interface in Java

Here are the most important reasons why you should use an interface in Java.

  • Easier to test
  • Faster development
  • Increased flexibility
  • Loosely couple code
  • Dependency Injection

Easier to test

One of the best things about using an interface in Java programming is that unit testing is easier.

DAO and parser classes are good examples. When testing, you can substitute interface dependencies with a mock, stub, or dummy.

Faster development

This is the fourth practical benefit of the Java interface I’ve seen. In a real project, your work depends on your partner’s or team’s.

Increased flexibility

The third benefit of the Java interface is that it makes code more flexible.

Loosely couple code

The fourth benefit of Java interface is that it makes loosely coupled programming easier to adapt and update. In loosely coupled code, you can modify bits without affecting the complete structure.

Dependency Injection

Lastly, the injection of dependencies is based on an interface.

In DI, instead of a developer putting in dependencies, the framework does it.

This is done by declaring dependencies as interfaces.


In summary, you have learned about interfaces in Java.

This article discusses what is an interface in Java, how to declare an interface in Java, an example of an interface in Java, use of an interface in Java, Interface Implementation, Extending Multiple Interfaces, Extending Interfaces, and Interface Advantages in Java

I hope this lesson has helped you learn a lot.

Check out my previous and latest articles for more life-changing tutorials which could help you a lot.

What’s Next

The next section talks about Packages. At the end of the session, you’ll know what is Packages all about in Java.

Leave a Comment