What are Interfaces in Java

In Java, an interface is a collection of abstract methods (without implementation) and constants (final variables) that can be implemented by classes. Interfaces allow the definition of a class contract must follow, specifying the methods that must be implemented by any class that implements the interface. Furthermore, a class can implement multiple interfaces, thus providing a form of multiple inheritance in Java.

Here are some key points about interfaces in Java:

Interface Declaration

To declare an interface in Java, the "interface" keyword is used. Methods declared in an interface are implicitly public and abstract.

public interface MyInterface {
     void method1();
     int method2();
}

Interface Implementation

To implement an interface in a class, use the "implements" keyword. The class must provide an implementation for all methods declared in the interface.

public class MyClass implements MyInterface {
     @Override
     public void method1() {
         // Implementation of method1
     }
     @Override
     public int method2() {
         // Implementation of method2
         return 42;
     }
}

Multiple Inheritance with Interfaces

Unlike classes, a class can implement multiple interfaces. This provides a form of multiple inheritance in Java, which is not allowed for classes.

public class MyClass implements Interface1, Interface2 {
     // Implementation of interface methods
}

Constants in Interfaces

Interfaces can contain constants, which are implicitly public, static, and final. Starting from Java 8, interfaces can also have methods with default implementation (default methods) and static methods.

public interface MyInterface {
     int CONSTANT = 42; // Constant
     void method1(); // Abstract method
     default void defaultmethod() {
         // Default implementation for the method (as of Java 8)
     }
}

Polymorphism by Interfaces

Polymorphism in Java is often achieved through the use of interfaces. An interface reference can point to an object of any class that implements that interface, providing flexibility and extensibility in code design.

MyInterface object = new MyClass();

Interfaces play an important role in software development in Java, facilitating the creation of modular code, promoting polymorphism, and allowing the implementation of clear contracts between classes.