Interfaces in Java

Introduction

An interface is a blueprint that defines a set of behaviours that implementing classes must provide. It specifies what a class should do without requiring one particular implementation.

Interfaces are mainly used to achieve abstraction, support polymorphism, and allow a class to follow multiple sets of behaviour.

Syntax of an Interface

An interface is declared using the interface keyword.

1interface InterfaceName {
2    void methodName();
3}

A class uses the implements keyword to implement an interface.

1class ClassName implements InterfaceName {
2    public void methodName() {
3        // Method implementation
4    }
5}

Features of Interfaces

Interfaces cannot be instantiated directly.
Methods without bodies are implicitly public and abstract.
Interface fields are implicitly public, static, and final.
A class can implement multiple interfaces.
An interface can extend another interface.
Implementing methods must be declared public.
Interfaces help achieve abstraction and polymorphism.

Interface Example in Java

1// Interface defines a payment behaviour
2interface Payment {
3
4    // Abstract method has no implementation
5    // It is implicitly public and abstract
6    void pay(double amount);
7}
8
9// CardPayment implements the Payment interface
10class CardPayment implements Payment {
11
12    // Provide the implementation of the interface method
13    @Override
14    public void pay(double amount) {
15        System.out.println("Paid " + amount + " using card."); 
16    }
17}
18
19public class Main {
20    public static void main(String[] args) {
21
22        // Create a CardPayment object using an interface reference
23        Payment payment = new CardPayment();
24
25        // Call the implemented interface method
26        payment.pay(500);   // Output :- Paid 500.0 using card.
27    }
28}

In this example, the Payment interface declares the pay() method. The CardPayment class implements the interface and provides the actual payment logic.

Interface

Multiple Interfaces in Java

Java does not allow a class to extend multiple classes. However, one class can implement multiple interfaces.

1// First interface defines printable behaviour
2interface Printable {
3    void print();
4}
5
6// Second interface defines scannable behaviour
7interface Scannable {
8    void scan();
9}
10
11// Printer implements two interfaces
12class Printer implements Printable, Scannable {
13
14    // Implement the method from Printable
15    @Override
16    public void print() {
17        System.out.println("Printing document."); 
18    }
19
20    // Implement the method from Scannable
21    @Override
22    public void scan() {
23        System.out.println("Scanning document."); 
24    }
25}
26
27public class Main {
28    public static void main(String[] args) {
29
30        // Create an object of the implementing class
31        Printer printer = new Printer();
32
33        // Call methods from both interfaces
34        printer.print();  // Output :- Printing document.
35        printer.scan();  // Output :- Scanning document.
36    }
37}

Here, the Printer class follows the behaviours defined by both Printable and Scannable.

Multiple interfaces in Java

Types of Interface Methods

Abstract Methods

Abstract methods do not contain a body. Implementing classes must define them.

1void display();

Default Methods

A default method contains an implementation and uses the default keyword.

1default void showMessage() {
2    System.out.println("Default interface method."); // Output :- Default interface method.
3}

Static Methods

A static interface method belongs to the interface and is called using its name.

1static void information() {
2    System.out.println("Static interface method."); // Output :- Static interface method.
3}

Types of interface method

Interface vs Abstract Class

Interface	Abstract Class
Implemented using `implements`.	Extended using `extends`.
A class can implement multiple interfaces.	A class can extend only one abstract class.
Fields are constants by default.	Can contain instance attributes.
Does not have constructors.	Can have constructors.
Suitable for defining common behaviour.	Suitable for sharing data and common code between related classes.

Advantages of Interfaces

Abstraction: Hides implementation details.
Multiple behaviours: A class can implement multiple interfaces.
Loose coupling: Code can depend on an interface rather than a specific class.
Consistency: Different classes can follow the same method structure.
Flexibility: Implementations can change without changing the interface.

Summary

An interface in Java defines behaviours that implementing classes must provide. Interfaces help achieve abstraction, polymorphism, loose coupling, and multiple interface implementation.

A class can implement one or more interfaces using the implements keyword and provide separate implementations for their methods.