Interface in Java

Interfaces are a powerful tool in Java that allow for the creation of abstractions and the implementation of multiple inheritance. In this blog post, we’ll go over what is interface in Java, how to define and implement them, and how to apply them in our code.

What is an interface in Java?

An interface in Java is a blueprint for a set of methods that a class can implement. It defines a set of abstract methods, which are methods that have a declaration but no implementation. When a class implements an interface, it must provide an implementation for all of the methods defined in the interface.

Interfaces are similar to classes in that they can contain constants and default methods (methods with a default implementation). However, unlike classes, interfaces cannot contain fields or constructors and all of their methods are abstract by default.

How to define an interface in Java?

To define an interface in Java, we use the interface keyword followed by the name of the interface and a set of method declarations. Here’s an example of a simple interface called Shape that has an abstract method called area():

public interface Shape {
    double area();
}

In this example, Shape is an interface with a single abstract method called area(). This method takes no arguments and returns a double.

How to implement an interface in Java?

To implement an interface, a class must use the implements keyword followed by the name of the interface. The class must then provide an implementation for all of the methods defined in the interface. Here’s an example of a Rectangle class that implements the Shape interface:

public class Rectangle implements Shape {
    private double width;
    private double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
}

In this example, the Rectangle class implements the Shape interface and provides an implementation for the area() method. The @Override annotation is optional but recommended as it helps to ensure that the correct method is being overridden.

Applying an interface

Now that we have a class that implements the Shape interface, we can use it just like any other class. Here’s an example of how we might use the Rectangle class:

Shape rectangle = new Rectangle(5, 10);
System.out.println("Area of rectangle: " + rectangle.area());

In this example, we create a new Rectangle object and assign it to a variable of type Shape. We can then call the area() method on the rectangle variable just like we would with any other object.

Conclusion

Interfaces are a useful tool in Java for creating abstractions and implementing multiple inheritance. They allow us to define a set of methods that a class must implement, and provide a way for us to use those methods without worrying about the implementation details. By following the examples in this blog post, we should now have a good understanding of how to define, implement, and apply interfaces in our own Java code.

FAQs