Java Interfaces

In this tutorial, we're going to talk about interfaces in Java. We'll also see how Java uses them to implement polymorphism and multiple inheritances.

In Java, an interface is an abstract type that contains a collection of methods and constant variables. It is one of the core concepts in Java and is used to achieve abstraction, polymorphism and multiple inheritances.

Let's see a simple example of an interface in Java:

We can implement an interface in a Java class by using the implements keyword.

Next, let's also create a Computer class that implements the Electronic interface we just created:

In an interface, we're allowed to use:

• constants variables
• abstract methods
• static methods
• default methods

We also should remember that:

• we can't instantiate interfaces directly
• an interface can be empty, with no methods or variables in it
• we can't use the final word in the interface definition, as it will result in a compiler error
• all interface declarations should have the public or default access modifier; the abstract modifier will be added automatically by the compiler
• an interface method can't be protected or final
• up until Java 9, interface methods could not be private; however, Java 9 introduced the possibility to define private methods in interfaces
• interface variables are public, static, and final by definition; we're not allowed to change their visibility

We use interfaces to add certain behavioral functionality that can be used by unrelated classes. For instance, Comparable, Comparator, and Cloneable are Java interfaces that can be implemented by unrelated classes. Below is an example of the Comparator interface that is used to compare two instances of the Employee class:

Java classes support singular inheritance. However, by using interfaces, we're also able to implement multiple inheritances.

For instance, in the example below, we notice that the Car class implements the Fly and Transform interfaces. By doing so, it inherits the methods fly and transform:

Let's start with asking the question: what is polymorphism? It's the ability for an object to take different forms during runtime. To be more specific it's the execution of the override method that is related to a specific object type at runtime.

In Java, we can achieve polymorphism using interfaces. For example, the Shape interface can take different forms — it can be a Circle or a Square.

Let's start by defining the Shape interface:

Now let's also create the Circle class:

And also the Square class:

Finally, it's time to see polymorphism in action using our Shape interface and its implementations. Let's instantiate some Shape objects, add them to a List, and, finally, print their names in a loop:

• Traditional interfaces in Java 7 and below don't offer backward compatibility.
• What this means is that if you have legacy code written in Java 7 or earlier, and you decide to add an abstract method to an existing interface, then all the classes that implement that interface must override the new abstract method. Otherwise, the code will break.
• Java 8 solved this problem by introducing the default method that is optional and can be implemented at the interface level.

• In order to achieve multiple inheritances thru interfaces, we have to remember a few rules. Let's go over these in detail.

• When an interface extends another interface, it inherits all of that interface's abstract methods. Let's start by creating two interfaces, HasColor and Shape:

In the example above, Box inherits from HasColor using the keyword extends. By doing so, the Box interface inherits getColor. As a result, the Box interface now has two methods: getColor and getHeight.

When an abstract class implements an interface, it inherits all of its abstract and default methods. Let's consider the Transform interface and the abstract class Vehicle that implements it:

In this example, the Vehicle class inherits two methods: the abstract transform method and the default printSpecs method.

• Java has had many functional interfaces since its early days, such as Comparable (since Java 1.2) and Runnable (since Java 1.0).
• Java 8 introduced new functional interfaces such as Predicate, Consumer, and Function. 

In this tutorial, we gave an overview of Java interfaces, and we talked about how to use them to achieve polymorphism and multiple inheritances.