Interface in Java

Introduction
Java is an object-oriented programming language that uses interfaces to define and enforce contracts between different parts of a program. In Java, an interface is a collection of abstract methods that are defined but not implemented. This allows a class to implement an interface and provide its own implementation of the methods defined in the interface. This blog will cover everything you need to know about interfaces in Java.

What is an Interface in Java?
An interface in Java is a collection of abstract methods, static constants, and default methods. An interface is like a contract that defines what a class must do but not how it should do it. In other words, an interface specifies a set of behaviors that a class should implement. An interface can be thought of as a blueprint for a class.

An interface is declared using the interface keyword followed by the name of the interface. For example:

public interface MyInterface {

    // abstract methods
    public void method1();
    public void method2();
}

This interface declares two abstract methods, method1() and method2(). Any class that implements this interface must provide an implementation of these methods.

Why use Interfaces in Java?
Interfaces provide a way to achieve abstraction in Java. Abstraction allows us to separate the behavior of a class from its implementation. This makes the code more flexible and easier to maintain. By defining an interface, we can separate the contract from the implementation. This allows us to write code that depends on the contract instead of the implementation.

For example, consider a program that needs to perform some mathematical operations on a set of numbers. We can define an interface for these operations:

public interface MathOperation {

    public double operate(double num1, double num2);
}

Now we can write a class that implements this interface and provides its own implementation of the operate() method:

public class Addition implements MathOperation {

    public double operate(double num1, double num2) {
        return num1 + num2;
    }
}

We can also write another class that implements the MathOperation interface and provides its own implementation of the operate() method:

public class Subtraction implements MathOperation {

    public double operate(double num1, double num2) {
        return num1 - num2;
    }
}

Now we can use these classes in our program without worrying about how they implement the MathOperation interface. This makes the code more flexible and easier to maintain.

How to use Interfaces in Java?
To use an interface in Java, we need to follow these steps:

Define an interface: We define an interface by declaring a collection of abstract methods using the interface keyword.

Implement the interface: We implement an interface by writing a class that provides an implementation of the abstract methods defined in the interface.

Use the interface: We use an interface by creating an object of the implementing class and calling its methods.

For example, consider the MathOperation interface and the classes that implement it:

public interface MathOperation {
    public double operate(double num1, double num2);
}

public class Addition implements MathOperation {
    public double operate(double num1, double num2) {
        return num1 + num2;
    }
}

public class Subtraction implements MathOperation {
    public double operate(double num1, double num2) {
        return num1 - num2;
    }
}

We can now use these classes in our program as follows:

MathOperation op1 = new Addition();
System.out.println(op1.operate(10, 5));

MathOperation op2 = new Subtraction();
System.out.println(op2.operate(10, 5));

In the above code, we create objects of the Addition and Subtraction classes and assign them to variables