Types of Interfaces in Java

In Java interfaces are essential, when it comes to setting class contracts and guaranteeing code consistency in the realm of Java programming. It serves as a class's blueprint by outlining a number of methods that the implementing class is required to implement. The abstraction, modularity, and maintainability of their code can all be achieved by developers by employing interfaces. The various interface types in Java will be discussed in this section.

Marker Interfaces

Marker interfaces, often called tag interfaces, are interfaces without any methods declared. Simply said, they serve as markers, signalling that a class that implements the marker interface has particular properties or qualities. The Java runtime environment and other tools make use of these APIs to deliver extra functionality or data. Serializable, Cloneable, and Remote are some instances of marker interfaces in Java.

Functional Interfaces

As part of the improvements to lambda expressions and functional programming, functional interfaces were added to Java 8. An interface that has precisely one abstract method is said to be functional. Additionally, default and static methods are possible. Many Java functional programming capabilities, like lambda expressions and method references, make use of functional interfaces. Predicate, Consumer, Function, and Supplier are just a few of the built-in functional interfaces offered by the java.util.function package.

Single Abstract Method (SAM) Interfaces

Prior to Java 8, there were certain kinds of functional interfaces called SAM interfaces. These interfaces can have any number of default or static methods, but only one abstract method. Runnable, Comparator, and MouseListener are a few pre-Java 8 APIs that contain SAM interface examples. With the introduction of functional interfaces in Java 8, SAM interfaces can be used with lambda expressions and considered as functional interfaces.

Normal Interfaces

The most prevalent kind of interfaces in Java is normal interfaces. They have one or more abstract methods that the classes that implement the interface must implement. Beginning with Java 8, normal interfaces can additionally contain default and static methods. Normal interfaces are used by developers to specify the rules or requirements that classes must follow. List, Set, and Map, all of which are found in the java.util package, are examples of typical Java interfaces.

Multiple Inheritance Interfaces

Java permits classes to implement multiple interfaces but does not support multiple class inheritance. Interfaces that are implemented by a class to simultaneously define numerous contracts or inherit behaviour are known as multiple inheritance interfaces. A class can offer the functionality outlined by each interface by implementing several interfaces. With the help of this functionality, developers can reuse code and increase the adaptability of their ideas.

Here are examples of code for each type of interface in Java along with their corresponding output:

Marker Interfaces

MarkerInterfaceExample.java

import java.io.Serializable;
// Marker Interface
interface MyMarkerInterface extends Serializable {
}
public class MarkerInterfaceExample {
    public static void main(String[] args) {
        MyMarkerInterface obj = new MyMarkerInterface() {
        };
        System.out.println(obj instanceof Serializable); // true
    }
}

Output:

true

Functional Interfaces

FunctionalInterfaceExample.java

import java.util.function.Predicate;
public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        Predicate<String> isLengthGreaterThan5 = str -> str.length() > 5;
        System.out.println(isLengthGreaterThan5.test("Hello")); // false
        System.out.println(isLengthGreaterThan5.test("OpenAI")); // true
    }
}

Output:

false
true

Single Abstract Method (SAM) Interfaces:

SAMInterfaceExample.java

interface MySAMInterface {
    void performAction();
}
public class SAMInterfaceExample {
    public static void main(String[] args) {
        MySAMInterface obj = () -> System.out.println("Performing action");
        obj.performAction(); // Performing action
    }
}

Output:

Performing action

Normal Interfaces

NormalInterfaceExample.java

import java.util.List;
import java.util.ArrayList;
interface MyInterface {
    void printMessage();
}
class MyClass implements MyInterface {
    @Override
    public void printMessage() {
        System.out.println("Hello, World!");
    }
}
public class NormalInterfaceExample {
    public static void main(String[] args) {
        MyInterface obj = new MyClass();
        obj.printMessage(); // Hello, World!
    }
}

Output:

Hello, World!

Multiple Inheritance Interfaces:

MultipleInheritanceInterfaceExample.java

interface Interface1 {
    void method1();
}
interface Interface2 {
    void method2();
}
class MyClass implements Interface1, Interface2 {
    @Override
    public void method1() {
        System.out.println("Method 1");
    }
    @Override
    public void method2() {
        System.out.println("Method 2");
    }
}
public class MultipleInheritanceInterfaceExample {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.method1(); // Method 1
        obj.method2(); // Method 2
    }
}

Output:

Method 1
Method 2

These examples demonstrate the usage and behavior of different types of interfaces in Java. You can run each code snippet individually to observe the corresponding output.

In conclusion, Java interfaces offer a potent method for specifying contracts and attaining code modularity. Interfaces are essential to Java development, whether they are marker interfaces that indicate specific traits, functional interfaces that enable functional programming, regular interfaces that define contracts, or multiple inheritance interfaces that combine several contracts. Java developers are better equipped to build clear, extendable code when they are aware of the various interface types and their functions.

Next TopicUnderstanding String Comparison Operator in Java

← prev next →