Java Interface

In Java, an interface is a collection of abstract methods and constant fields. An interface defines a contract between a class and the outside world and provides a way to define a common set of methods that can be implemented by multiple classes.

An interface can be defined using the interface keyword, and its methods are declared using the abstract keyword. Unlike abstract classes, interfaces cannot contain any method implementations, and all methods declared in an interface must be implemented by any class that implements the interface.

Here’s an example of an interface in Java:

interface Shape {
    double getArea();
    double getPerimeter();
}

In the above example, Shape is an interface that contains two abstract methods getArea() and getPerimeter(). Any class that implements the Shape interface must provide its own implementation of these two methods.

To implement an interface, a class must use the implements keyword followed by the name of the interface. For example:

class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

In the above example, Circle is a class that implements the Shape interface and provides its own implementation of the getArea() and getPerimeter() methods.

Interfaces can also contain constant fields, which are declared using the final keyword. These fields must be initialized when they are declared, and their values cannot be changed.

Here’s an example of an interface with a constant field in Java:

interface Constants {
    int MAX_VALUE = 100;
}

In the above example, Constants is an interface that contains one constant field MAX_VALUE. Any class that implements the Constants interface can use this constant field, and its value cannot be changed.

Multiple Interfaces

In Java, a class can implement multiple interfaces, which means that it can provide implementations for all the methods declared in all the interfaces it implements.

To implement multiple interfaces, a class must use the implements keyword followed by a comma-separated list of interface names. For example:

interface Shape {
    double getArea();
    double getPerimeter();
}

interface Printable {
    void print();
}

class Circle implements Shape, Printable {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
    
    public void print() {
        System.out.println("Circle with radius " + radius);
    }
}

In the above example, Circle is a class that implements both the Shape and Printable interfaces, which means that it provides implementations for all the methods declared in both interfaces (getArea(), getPerimeter(), and print()).

Implementing multiple interfaces allows classes to have a more diverse set of behaviors, and makes it easier to reuse code by separating functionality into interfaces that can be implemented by multiple classes. It also helps to avoid the limitations of multiple inheritance, which can cause conflicts when two or more superclasses have the same method name with different implementations.

Java interfaces are an important part of Java’s object-oriented programming model. They provide a way to define a common set of methods and constants that can be implemented by multiple classes, which helps to create more modular and extensible code.

Share on Facebook

Save