Interface in Java
Interface in Java
Interface in Java:
In Java, an interface is a collection of abstract methods and constants. It is a programming construct that allows you to define a set of methods that a class must implement. An interface can be used to define a contract that a class must follow, without specifying the implementation details.
An interface is declared using the interface keyword, and the methods defined in the interface are implicitly public and abstract. Constants in an interface are implicitly public, static, and final. Here’s an example:
public interface MyInterface {
int MAX_VALUE = 100; // constant
void method1(); // abstract method
void
To implement an interface, a class must use the implements keyword, and provide an implementation for all the methods declared in the interface. Here’s an example:
public class MyClass implements MyInterface {
@Override
public void method1() {
// implementation
}
@Override
public void method2() {
// implementation
}
}
In the example above, MyClass implements the MyInterface interface, and provides an implementation for the method1() and method2() abstract methods.
An interface can also extend one or more other interfaces using the extends keyword. Here’s an example:
public interface MySubInterface extends MyInterface {
void method3(); // abstract method
}
In the example above, MySubInterface extends MyInterface, and declares an additional abstract method method3().
Interfaces are often used in Java to define APIs (Application Programming Interfaces) and provide a way for different classes to communicate with each other without needing to know the implementation details. They are also used to implement polymorphism in Java.