Interface in Java - Contracts, Capabilities and Multiple Inheritance

⏱️ 24 min read • Beginner Level • Lesson 58

An interface in Java defines a contract or capability that implementing classes agree to provide.

Interfaces help separate what a component can do from how it does it. They support abstraction, loose coupling, runtime polymorphism, multiple inheritance of type, focused APIs, and interchangeable implementations.

What Is an Interface in Java?

An interface is a reference type that describes operations, constants, and supported method implementations. A class uses the implements keyword to accept an interface contract.

Real-World Analogy

A wall socket defines a standard connection. Different devices can use that connection while their internal electronics remain different. Similarly, an interface defines a standard contract that different classes can implement in their own way.

Java Interface Syntax

interface InterfaceName {
    void requiredMethod();
}

class ClassName implements InterfaceName {
    @Override
    public void requiredMethod() {
        // implementation
    }
}

Basic Interface Example

interface NotificationService {
    void send(String message);
}

class EmailService implements NotificationService {
    @Override
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

class SmsService implements NotificationService {
    @Override
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

class NotificationExample {
    static void notifyUser(
            NotificationService service, String message) {
        service.send(message);
    }

    public static void main(String[] args) {
        notifyUser(new EmailService(), "Order confirmed");
        notifyUser(new SmsService(), "Order shipped");
    }
}

Output:

Email: Order confirmed
SMS: Order shipped

Members Allowed in an Interface

Interface Fields

Every field declared in an interface is implicitly public static final and must be initialized.

interface Configuration {
    int MAX_RETRIES = 3;
    String APP_NAME = "ProwessApps";
}

class ConfigDemo {
    public static void main(String[] args) {
        System.out.println(Configuration.APP_NAME);
        System.out.println(Configuration.MAX_RETRIES);
    }
}

Output:

ProwessApps
3

Abstract Interface Methods

A method declared without a body in an interface is implicitly public abstract. The implementing class must provide a public implementation unless it is abstract or inherits a valid implementation.

Default Methods

A default method has a body and is inherited by implementing classes. Default methods help interfaces evolve by adding behavior without immediately breaking every existing implementation.

interface Printer {
    void print(String text);

    default void printHeader() {
        System.out.println("=== Document ===");
    }
}

class ConsolePrinter implements Printer {
    @Override
    public void print(String text) {
        System.out.println(text);
    }

    public static void main(String[] args) {
        ConsolePrinter printer = new ConsolePrinter();
        printer.printHeader();
        printer.print("Java Interface");
    }
}

Output:

=== Document ===
Java Interface

Static Methods in Interfaces

A static interface method belongs to the interface and is called with the interface name. It is not inherited as an instance method by implementing classes.

interface Validator {
    static boolean isPositive(int number) {
        return number > 0;
    }
}

class ValidatorDemo {
    public static void main(String[] args) {
        System.out.println(Validator.isPositive(10));
    }
}

Output:

true

Private Methods in Interfaces

Modern Java interfaces can use private instance and private static methods to reuse internal logic between default and static methods. Implementing classes cannot call or override these private helpers.

interface Logger {
    default void info(String message) {
        log("INFO", message);
    }

    default void error(String message) {
        log("ERROR", message);
    }

    private void log(String level, String message) {
        System.out.println(level + ": " + message);
    }
}

Implementing Multiple Interfaces

A Java class can implement multiple interfaces. This allows one class to support several independent capabilities without extending multiple classes.

interface Camera {
    void takePhoto();
}

interface MusicPlayer {
    void playMusic();
}

class Smartphone implements Camera, MusicPlayer {
    @Override
    public void takePhoto() {
        System.out.println("Photo captured");
    }

    @Override
    public void playMusic() {
        System.out.println("Music playing");
    }

    public static void main(String[] args) {
        Smartphone phone = new Smartphone();
        phone.takePhoto();
        phone.playMusic();
    }
}

Output:

Photo captured
Music playing

One Interface Extending Another

An interface uses extends to inherit from one or more interfaces. A class implementing the child interface must satisfy the complete inherited contract.

interface Printable {
    void print();
}

interface Scannable {
    void scan();
}

interface MultiFunctionDevice
        extends Printable, Scannable {
    void copy();
}

Resolving Default-Method Conflicts

If two implemented interfaces provide default methods with the same signature, the implementing class must override the method and resolve the conflict explicitly.

interface A {
    default void show() {
        System.out.println("A");
    }
}

interface B {
    default void show() {
        System.out.println("B");
    }
}

class ConflictExample implements A, B {
    @Override
    public void show() {
        A.super.show();
        B.super.show();
        System.out.println("Resolved");
    }

    public static void main(String[] args) {
        new ConflictExample().show();
    }
}

Output:

A
B
Resolved

Functional Interfaces

A functional interface has exactly one abstract method. It may also contain default, static, and private methods. Functional interfaces are targets for lambda expressions and method references.

@FunctionalInterface
interface Calculator {
    int calculate(int first, int second);
}

class CalculatorExample {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.calculate(10, 20));
    }
}

Output:

30

Interface References and Polymorphism

An interface reference can point to any object whose class implements that interface. The actual object's overridden method executes at runtime.

Interface vs Abstract Class

Important Interface Rules

Interface Best Practices

Tricky Cases

1. Can an interface have a constructor?

2. Can an interface have private methods?

3. Are interface methods always abstract?

4. Can a class implement two interfaces with the same abstract method?

5. What if two interfaces provide the same default method?

6. Can an interface extend a class?

7. Can an abstract class implement an interface partially?

Common Mistakes

Interview Questions ⭐

Test your understanding with a quick quiz

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

class Test {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.calculate(10, 20));
    }
}

interface Printable {
    void print();
}

class Report implements Printable {
    void print() {
        System.out.println("Report");
    }
}

interface Animal {
    void sound();
}

class Dog implements Animal {
    public void sound() {
        System.out.println("Woof");
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound();
    }
}

Great job! Continue learning Java OOP step by step.