Java Interfaces: A Guide for Beginners

If you’re just starting out with Java programming, you might have heard a lot about interfaces, but don’t know exactly what they are or why they’re important. In this article, we’ll take a closer look at Java interfaces and explain why they’re so valuable for your code.

So, what exactly is an interface in Java? In simple terms, an interface is a blueprint for a class that defines what methods a class must implement. They define a set of methods and properties that a class must implement. Essentially, interfaces provide a way for a class to say “I promise to have these methods.”

Interfaces are an important part of Java, and they provide several benefits, such as:

• Abstraction: Interfaces allow you to define the behavior of a class without providing the implementation details.
• Polymorphism: Interfaces enable you to write code that works with objects of different types.
• Reusability: Interfaces can be reused in multiple classes, making it easier to maintain your code.

So, why use interfaces in Java? The answer is simple: to make your code more flexible, maintainable, and reusable.

Now, let’s see how to use interfaces in Java. To create an interface, you use the interface keyword, followed by the name of the interface and a list of methods that must be implemented. Here's an example:

interface MyInterface {
    void doSomething();
    int getValue();
}

To implement this interface, you use the implements keyword in your class, followed by the name of the interface. Then, you must provide an implementation for each of the methods in the interface:

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        // implementation here
    }
    @Override
    public int getValue() {
        // implementation here
    }
}

Now that you have a basic understanding of how interfaces work, let’s take a look at the different types of interfaces in Java.

Types of Interfaces in Java

1. Marker Interfaces:

These are interfaces without any methods or fields, used to indicate that a class has a certain property. For example, the Serializable interface is a marker interface that indicates that an object can be serialized (i.e. converted to a stream of bytes).

interface Serializable {
    // No methods or fields
}

Here’s an example of how you can use the Serializable marker interface to serialize an object:

class MySerializableClass implements Serializable {
    private int value;
    public int getValue() { return value; }
    public void setValue(int value) { this.value = value; }
}

// ...

MySerializableClass obj = new MySerializableClass();
obj.setValue(42);

try (FileOutputStream fileOut = new FileOutputStream("myObject.ser");
     ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
    out.writeObject(obj);
}

Here’s an example of how you can create your own marker interface called MyMarkerInterface:

public interface MyMarkerInterface {
}

Now, you can use this marker interface in a similar way to the Serializable marker interface, marking classes that need to be processed in a specific way:

class MyClass implements MyMarkerInterface {
    // ...
}

2. Functional Interfaces:

As the name suggests, these interfaces have only one abstract method. They were introduced in Java 8 and are used in conjunction with lambda expressions to create more concise and functional code. For example, the Predicate interface represents a boolean-valued function of one argument, which is useful when you want to check if a certain condition is met.

interface Predicate<T> {
    boolean test(T t);
}

Here’s an example of how you can use the Predicate functional interface to filter a list of numbers:

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Predicate<Integer> isEven = number -> number % 2 == 0;
        numbers.stream().filter(isEven).forEach(System.out::println);
    }
}

Here’s an example of how you can create your own functional interface called MyFunctionalInterface:

@FunctionalInterface
public interface MyFunctionalInterface {
    int process(int a, int b);
}

Now, you can use this functional interface to create a lambda expression or method reference that implements the process method:

MyFunctionalInterface add = (a, b) -> a + b;
System.out.println(add.process(3, 4)); // 7

3. Generic Interfaces:

These interfaces are parameterized by one or more type parameters, making them more flexible and easier to reuse in multiple contexts. For example, the following is a simple generic interface in Java:

Here’s an example of how you can create your own generic interface called MyGenericInterface:

public interface MyGenericInterface<T> {
    T getValue();
}

Now, you can use this generic interface in a similar way to the example we saw before:

class MyClass<T> implements MyGenericInterface<T> {
    private T value;
    public MyClass(T value) { this.value = value; }
    @Override
    public T getValue() { return value; }
}

You can then create instances of MyClass with specific types, such as Integer, String, etc., and use the MyGenericInterface to retrieve the value:

MyClass<Integer> myInt = new MyClass<>(123);
System.out.println(myInt.getValue()); // 123

MyClass<String> myString = new MyClass<>("Hello");
System.out.println(myString.getValue()); // Hello

And those are the main types of interfaces in Java! There are also single abstract method (SAM) interfaces, extended interfaces, adapters, and callback interfaces, but those are less commonly used.

Java provides a number of pre-defined interfaces that you can use in your code, such as Comparable, Runnable, Cloneable, Iterable, etc. These interfaces are part of the Java API and you can find more information on how to use them in the Java documentation.

Conclusion

Interfaces are an important part of Java, they provide several benefits, such as abstraction, polymorphism & reusability and will make your code more flexible, reusable, and organised.

Whether you’re a beginner or an experienced Java developer, it’s important to understand how interfaces work and how to use them in your code. So, grab a cup of coffee, sit back, and start experimenting with interfaces today!