What is interface in Java with Example - Tutorial

What is an interface in Java?
Interface in java is a core part of the Java programming language and one of the ways to achieve abstraction in Java along with the abstract class. Even though the interface is a fundamental object-oriented concept; Many Java programmers think of Interface in Java as an advanced concept and refrain from using the interface from early in a programming career. At a very basic level interface in java is a keyword but same time it is an object-oriented term to define contracts and abstraction, This contract is followed by any implementation of Interface in Java. Since multiple inheritances are not allowed in Java, the interface is the only way to implement multiple inheritances at the Type level.


In this Java tutorial, we will see What is an interface in Java, How to use an interface in Java, and where to use the interface in Java, and some important points related to the Java interface. What is an interface in Java is also a common core Java question which people asked on various programming exams and interviews.

Key Points about Interface in Java

In the last section, we saw What is an interface in Java and learned that interface provides abstraction in Java and its only way to achieve multiple inheritances at type level in Java. In this section, we will see some important properties of the interface in Java.

1. The interface in java is declared using a keyword interface and it represents a Type like any Class in Java. a reference variable of type interface can point to any implementation of that interface in Java. 

Its also a good Object-oriented design principle to "program for interfaces than implementation" because when you use interface to declare reference variable, method return type, or method argument you are flexible enough to accept any future implementation of that interface which could be the much better and high-performance alternative of the current implementation. 

Similarly calling any method on the interface doesn't tie you with any particular implementation and you can leverage the benefit of better or improved implementation over time. This maintenance aspect of the interface is also sought in various software design interview questions in Java.

2) All variables declared inside interface is implicitly public final variable or constants. which brings a useful case of using Interface for declaring Constants. We have used both Class and interface for storing application wide constants and advantage of using Interface was that you can implement interface and can directly access constants without referring them with class name which was the case earlier when Class is used for storing Constants. Though after introduction of static imports in Java 5 this approach doesn't offer any benefit over Class approach.

3) All methods declared inside Java Interfaces are implicitly public and abstract, even if you don't use public or abstract keyword. you can not define any concrete method in interface. That's why interface is used to define contracts in terms of variables and methods and you can rely on its implementation for performing job.

4) In Java its legal for an interface to extend multiple interface. for example following code will run without any compilation error:

interface Session extends Serializable, Clonnable{ }

Here Session interface in Java is also a Serializable and Clonnable. This is not true for Class in Java and one Class can only extend at most another Class. In Java one Class can implement multiple interfaces. They are required to provide implementation of all methods declared inside interface or they can declare themselves as abstract class.

Example of the interface in Java

Java standard library itself has many inbuilt interfaces like Serializable, Cloneable, Runnable or Callable interface in Java.  Declaring the interface is easy but making it correct in the first attempt is hard but if you are in the business of designing API then you need to get it right in the first attempt because it's not possible to modify interface once it released without breaking all its implementation. here is an example of declaring interface in Java :

 interface SessionIDCreator extends Serializable, Cloneable{
        String TYPE = "AUTOMATIC";
        int createSessionId();
    }
 
    class SerialSessionIDCreator implements SessionIDCreator{

        private int lastSessionId;
       

 @Override
        public int createSessionId() {
            return lastSessionId++;
        }
     
    }

In above example of interface in Java, SessionIDCreator is an interface while SerialSessionIDCreator is a implementation of interface. @Override annotation can be used on interface method from Java 6 onwards, so always try to use it. Its one of those coding practice which should be in your code review checklist.

When to use interface in Java?

The interface is the best choice for Type declaration or defining contract between multiple parties. If multiple programmers are working in the different modules of the project they still use each other's API by defining the interface and not waiting for actual implementation to be ready. 

This brings us a lot of flexibility and speed in terms of coding and development. Use of Interface also ensures best practices like "programming for interfaces than implementation" and results in more flexible and maintainable code. 


Though interface in Java is not the only one who provides higher-level abstraction, you can also use abstract class but choosing between Interface in Java and abstract class is a skill. The difference between Interface in Java and abstract class in java is also a very popular java interview question.

That's it for now on What is Interface in Java, specifics of Java interface, and How and when to use Interface in Java.  The interface is key to write flexible and maintainable code. If you are not yet using the interface in your code then start thinking in terms of interfaces and use it as much possible. You will learn more about interfaces when you start using design patterns. many design patterns like decorator pattern, Factory method pattern or Observer design pattern makes very good use of Java interfaces.

Other Java tutorials you may like

Why char array is better than String for storing password in Java

How to avoid  Race condition in Java with example

Why Java does not support Operator overloading?

Why Wait and notify are defined in Object Class?

Why using Runnable is better than Thread for declaring Task

How to write equals method in Java with unit test