Interface In Java

Interfaces in Java

An interface in Java is a reference type that contains only abstract methods (until Java 8), default methods, static methods, and constant declarations. It's a way to achieve abstraction and multiple inheritance in Java.

Key Characteristics of Interfaces

All methods are abstract by default (before Java 8)
Cannot be instantiated directly
No constructors
All fields are public, static, and final by default
A class can implement multiple interfaces

Basic Interface Syntax

public interface Vehicle {
    // Constant (implicitly public, static, final)
    int MAX_SPEED = 120;

    // Abstract method (implicitly public and abstract)
    void start();
    void stop();

    // Default method (Java 8+)
    default void honk() {
        System.out.println("Honking the horn");
    }

    // Static method (Java 8+)
    static int getMaxSpeed() {
        return MAX_SPEED;
    }
}

Implementing an Interface

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car started");
    }

    @Override
    public void stop() {
        System.out.println("Car stopped");
    }

    // Can override default method (optional)
    @Override
    public void honk() {
        System.out.println("Car horn: Beep Beep!");
    }
}

New Features in Later Java Versions

Java 8 Additions

Default methods: Provide default implementation for methods
Static methods: Utility methods related to the interface

Java 9 Additions

Private methods: For code reuse within the interface

Multiple Inheritance with Interfaces

interface A {
    void methodA();
}

interface B {
    void methodB();
}

class C implements A, B {
    public void methodA() { /* implementation */ }
    public void methodB() { /* implementation */ }
}

Interface vs Abstract Class

Feature	Interface	Abstract Class
Methods	All abstract (pre-Java 8)	Can have concrete methods
Variables	Only constants	Any variables
Inheritance	Multiple	Single
Constructors	No	Yes
Access modifiers	Public by default	Can be any
State	No instance state	Can maintain state

Functional Interfaces (Java 8+)

An interface with exactly one abstract method (can have multiple default/static methods):

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);

    default void printResult(int result) {
        System.out.println("Result: " + result);
    }
}