What is Interface in Java ?

Definition:

An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain method implementations (except default and static methods). They define a contract that classes must follow, specifying what methods a class must implement without dictating how the methods should be implemented. A class can implement multiple interfaces.

Example:

// Defining the interface
interface Animal {
    // Abstract methods
    void eat();
    void sleep();

    // Default method
    default void breathe() {
        System.out.println("Animal is breathing...");
    }
}

// Implementing the interface
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating...");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping...");
    }
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating...");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping...");
    }
}

// Main class to demonstrate
public class InterfaceExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        // Dog behavior
        dog.eat();
        dog.sleep();
        dog.breathe();

        // Cat behavior
        cat.eat();
        cat.sleep();
        cat.breathe();
    }
}

Output:

Dog is eating...
Dog is sleeping...
Animal is breathing...
Cat is eating...
Cat is sleeping...
Animal is breathing...

Features of Interfaces in Java:

• Interfaces can only have abstract methods (prior to Java 8). Starting from Java 8, they can also have default and static methods .
• Interfaces can only contain constants (final variables); they cannot store instance variables or object states.
• A class can implement multiple interfaces, thus providing multiple inheritance.
• Interfaces provide loose coupling between classes, promoting flexibility in code architecture.
• Starting from Java 8, interfaces can have default method implementations, allowing new methods to be added without breaking existing implementations.

Advantages of Using Interfaces:

• Java does not support multiple inheritance with classes but allows it with interfaces. A class can implement multiple interfaces, which helps in modularizing behavior.
• Interfaces define a contract that must be fulfilled, enabling abstraction by hiding implementation details from the user.
• Interfaces decouple the definition of behaviors from the actual implementation, making the system more modular and flexible.
• Interfaces make it easier to test code by allowing for dependency injection and mock implementations.
• Interfaces allow easy addition of new behaviors to a class without modifying its existing functionality.

Uses of Interfaces in Java:

• Interfaces are commonly used in APIs to define a contract that different classes (even from other developers) can implement without exposing the internal logic.
• Java GUI frameworks use interfaces (e.g., ActionListener) to handle events like button clicks.
• Interfaces are used in frameworks like Spring to inject different implementations of a service dynamically.
• Interfaces allow for polymorphism, where a single method or function can process objects of different classes that implement the same interface.
• Interfaces allow different modules or layers in a software application to interact while keeping their internal workings hidden.