Java Interface

Introduction

An interface in Java is a reference type that contains only abstract methods and static constants. Interfaces provide a way to achieve full abstraction and multiple inheritance in Java. They define a contract that classes must follow, ensuring a certain level of consistency across different classes.

Table of Contents

1. What is an Interface?
2. Benefits of Using Interfaces
3. Defining and Implementing Interfaces
4. Default, Static, and Private Methods in Interfaces
5. Multiple Inheritance with Interfaces
6. Real-World Analogy
7. Example: Interface
8. Conclusion

1. What is an Interface?

An interface in Java is a blueprint of a class that contains static constants and abstract methods. The methods in an interface do not have a body (they are abstract) and must be implemented by classes that choose to implement the interface.

Key Points:

• Interfaces can contain abstract methods and static constants.
• Interfaces cannot contain instance fields or constructors.
• Classes implement interfaces using the implements keyword.
• A class can implement multiple interfaces, providing a form of multiple inheritance.

2. Benefits of Using Interfaces

• Full Abstraction: Interfaces allow you to achieve full abstraction by defining only method signatures and constants, without any implementation.
• Multiple Inheritance: A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources.
• Loose Coupling: Interfaces help in achieving loose coupling by providing a contract that classes can follow, allowing for more flexible and interchangeable code.

3. Defining and Implementing Interfaces

Interfaces are defined using the interface keyword. Classes implement interfaces using the implements keyword and must provide implementations for all abstract methods declared in the interface.

Syntax:

interface InterfaceName {
    // Abstract method
    void methodName();
}

class ClassName implements InterfaceName {
    @Override
    public void methodName() {
        // method body
    }
}

4. Default, Static, and Private() Methods in Interfaces

Starting from Java 8, interfaces can have default and static methods. Java 9 introduced private methods in interfaces. Default methods provide a default implementation that classes can override, while static methods belong to the interface itself and cannot be overridden by implementing classes. Private methods can be used to share common code between default methods in the same interface.

Default Methods (Java 8)

Default methods allow the addition of new methods to interfaces without breaking the existing implementation of classes. They provide a default implementation that can be overridden by implementing classes.

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

    // Default method
    default void defaultMethod() {
        System.out.println("Default method in the interface.");
    }
}

Static Methods (Java 8)

Static methods in interfaces are similar to static methods in classes. They belong to the interface and cannot be overridden by implementing classes.

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

    // Static method
    static void staticMethod() {
        System.out.println("Static method in the interface.");
    }
}

Private Methods (Java 9)

Private methods in interfaces allow you to share common code between default methods within the same interface.

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

    // Default method
    default void defaultMethod() {
        commonMethod();
        System.out.println("Default method in the interface.");
    }

    // Private method
    private void commonMethod() {
        System.out.println("Common code for default methods.");
    }
}

Example: Default, Static, and Private Methods

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

    // Default method
    default void defaultMethod() {
        commonMethod();
        System.out.println("Default method in the interface.");
    }

    // Static method
    static void staticMethod() {
        System.out.println("Static method in the interface.");
    }

    // Private method
    private void commonMethod() {
        System.out.println("Common code for default methods.");
    }
}

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

    @Override
    public void defaultMethod() {
        System.out.println("Overridden default method.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.abstractMethod();
        obj.defaultMethod();
        MyInterface.staticMethod();
    }
}

Output:

Implementation of abstract method.
Overridden default method.
Static method in the interface.

5. Multiple Inheritance with Interfaces

A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources. This is a form of multiple inheritance in Java.

Example: Multiple Inheritance with Interfaces

interface Animal {
    void eat();
}

interface Mammal {
    void walk();
}

class Dog implements Animal, Mammal {
    @Override
    public void eat() {
        System.out.println("The dog eats.");
    }

    @Override
    public void walk() {
        System.out.println("The dog walks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();
        myDog.walk();
    }
}

Output:

The dog eats.
The dog walks.

6. Real-World Analogy

Consider a real-world example of an electrical appliance:

• An interface Switchable might define methods like turnOn and turnOff.
• Different appliances like Fan, Light, and AirConditioner can implement the Switchable interface and provide specific implementations for turning on and off.

This way, you can treat any switchable appliance in a uniform manner, regardless of its specific type.

7. Example: Interface

Let’s create a more detailed example to demonstrate the use of interfaces in Java.

Example: Interface

// Interface
interface Shape {
    void draw();
    double calculateArea();
}

class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        circle.draw();
        System.out.println("Area of circle: " + circle.calculateArea());

        rectangle.draw();
        System.out.println("Area of rectangle: " + rectangle.calculateArea());
    }
}

Output:

Drawing a circle.
Area of circle: 78.53981633974483
Drawing a rectangle.
Area of rectangle: 24.0

In this example:

• The Shape interface defines two methods: draw and calculateArea.
• The Circle and Rectangle classes implement the Shape interface and provide specific implementations for the draw and calculateArea methods.
• The Main class demonstrates creating instances of Circle and Rectangle and calling their methods.

8. Conclusion

Interfaces in Java provide a powerful way to achieve full abstraction and multiple inheritance. They define a contract that implementing classes must follow, ensuring consistency and flexibility in your code. By understanding and using interfaces, you can create more modular, maintainable, and extensible Java applications. With the addition of default, static, and private methods in Java 8 and Java 9, interfaces have become even more versatile, allowing for the inclusion of default behavior while still maintaining the flexibility to override it in implementing classes.