Skip to main content

Interfaces in Java

  • 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 instance fields or constructors.

  • They are used to specify a set of methods that a class must implement, providing a way to achieve abstraction and multiple inheritance in Java.

  • Interfaces are an essential part of Java's approach to abstraction and polymorphism, allowing classes to interact with each other in a flexible and decoupled manner.

Key Characteristics of Interfaces​

  • Abstraction: Interfaces allow the definition of methods without implementation, ensuring that implementing classes provide the necessary functionality.

  • Multiple Inheritance: A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources.

  • Decoupling: Interfaces help in reducing the coupling between classes by providing a contract that classes must adhere to.

Defining an Interface​

  • An interface is defined using the interface keyword.

  • By default, all methods in an interface are abstract and public, and all fields are public, static, and final.

Syntax of Interface​

 interface MyInterface {
    // Abstract method (no implementation)
    void abstractMethod();

    // Default method (with implementation)
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    // Static method (with implementation)
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

Implementing an Interface​

  • A class implements an interface using the implements keyword.

  • The class must provide implementations for all abstract methods declared in the interface.

Example of Interface Implementation​

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating objects of Circle and Rectangle
        Drawable circle = new Circle();
        Drawable rectangle = new Rectangle();

        // Calling the draw method
        circle.draw();    // Outputs: Drawing a Circle
        rectangle.draw(); // Outputs: Drawing a Rectangle
    }
}

Explanation:​

  • Interface (Drawable): Contains an abstract method draw().

  • Implementing Classes (Circle and Rectangle): Implement the Drawable interface and provide implementations for the draw() method.

  • Using the Interface: Objects of Circle and Rectangle are created, and the draw() method is called.

Interface with Default and Static Methods​

Java 8 introduced default and static methods in interfaces, allowing methods with implementations to be included in interfaces.

Example of Interface with Default and Static Methods​

interface MyInterface {
    // Abstract method
    void abstractMethod();

    // Default method
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    // Static method
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Implementation of abstract method.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        
        // Calling abstract method
        obj.abstractMethod(); // Outputs: Implementation of abstract method.
        
        // Calling default method
        obj.defaultMethod();  // Outputs: This is a default method.
        
        // Calling static method
        MyInterface.staticMethod(); // Outputs: This is a static method.
    }
}

Explanation:​

  • Interface (MyInterface): Contains an abstract method abstractMethod(), a default method defaultMethod(), and a static method staticMethod().

  • Implementing Class (MyClass): Implements the MyInterface and provides an implementation for the abstractMethod().

  • Using the Interface: An object of MyClass is created, and the methods are called.

Multiple Inheritance with Interfaces​

A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources.

Example of Multiple Inheritance​

interface Printable {
    void print();
}

interface Showable {
    void show();
}

class Document implements Printable, Showable {
    @Override
    public void print() {
        System.out.println("Printing document");
    }

    @Override
    public void show() {
        System.out.println("Showing document");
    }
}

public class Main {
    public static void main(String[] args) {
        Document doc = new Document();
        
        // Calling methods
        doc.print(); // Outputs: Printing document
        doc.show();  // Outputs: Showing document
    }
}

Explanation:​

  • Interfaces (Printable and Showable): Contain abstract methods print() and show().

  • Implementing Class (Document): Implements both Printable and Showable interfaces and provides implementations for the print() and show() methods.

  • Using the Class: An object of Document is created, and the methods are called.

Advantages of Interfaces​

  • Multiple Inheritance: Allows a class to inherit behavior from multiple interfaces.

  • Decoupling: Reduces the dependency between classes, making the code more modular.

  • Flexibility: Provides a way to define methods that must be implemented by multiple classes, ensuring consistency.

Summary​

  • Interface: A reference type in Java that can contain only constants, method signatures, default methods, static methods, and nested types.

  • Abstract Methods: Methods without implementation that must be implemented by classes that implement the interface.

  • Default Methods: Methods with implementation introduced in Java 8, allowing interfaces to have methods with a default implementation.

  • Static Methods: Methods with implementation that belong to the interface rather than any instance of the class.

  • Multiple Inheritance: A class can implement multiple interfaces, inheriting behavior from multiple sources.

  • Benefits: Interfaces provide abstraction, multiple inheritance, decoupling, and flexibility, making the code more modular and easier to maintain.

Understanding interfaces is crucial for designing robust and maintainable object-oriented code in Java.