An interface in Java is a reference type, much like a class, that can contain only constants, method signatures, default methods, static methods, and nested types. However, interfaces cannot contain instance fields or constructors. They define a contract that any class can implement, thus providing a way to specify what methods a class should have, without dictating how they should be implemented.
In simple terms, an interface defines a contract that classes can choose to follow. A class that implements an interface agrees to provide concrete implementations for all the methods declared in the interface. Unlike classes, interfaces do not have any implementation details for the methods—they just specify what methods should exist.
An interface can be seen as a blueprint for classes. A class that implements an interface must provide definitions for all of the interface’s methods (unless the class is abstract, in which case it can leave method implementations to its subclasses).
Why Use Interfaces
- Code Reusability: Interfaces allow different classes to share a common set of methods, increasing code reuse.
- Loose Coupling: Interfaces help reduce dependencies between classes, leading to better maintainability and flexibility.
- Polymorphism: Java interfaces enable polymorphic behavior, allowing objects of different types to be treated as objects of a common interface type.
Defining an Interface
Example:
|
1 2 3 4 |
public interface Animal { void sound(); // abstract method, no body void eat(); // abstract method, no body } |
In this example:
Animalis an interface.- It has two abstract methods:
sound()andeat(), which don’t have any implementation.
Implementing an Interface
To implement an interface, a class must provide concrete implementations of all the methods declared in the interface. Here’s an example:
|
1 2 3 4 5 6 7 8 9 10 11 |
public class Dog implements Animal { // Providing the implementation for sound() method public void sound() { System.out.println("Bark"); } // Providing the implementation for eat() method public void eat() { System.out.println("Dog is eating"); } } |
- The
Dogclass implements theAnimalinterface. - It provides concrete implementations for the
sound()andeat()methods.
Features of Interfaces
- Abstract Methods: An interface can declare methods, but they must not have any body. These methods are abstract by default.
- Multiple Inheritance: Java allows a class to implement more than one interface, providing a way to mimic multiple inheritance. This is a key advantage of interfaces, as Java does not allow multiple inheritance with classes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public interface Flyer { void fly(); } public class Bird implements Animal, Flyer { public void sound() { System.out.println("Tweet"); } public void eat() { System.out.println("Bird is eating"); } public void fly() { System.out.println("Bird is flying"); } } |
- Default Methods: Java 8 introduced default methods, which allow you to add method implementations inside interfaces. This helps maintain backward compatibility with older versions.
|
1 2 3 4 5 |
public interface Animal { default void breathe() { System.out.println("Breathing"); } } |
- Static Methods: Interfaces can also have static methods, which must be called on the interface itself (not on the implementing class).
|
1 2 3 4 5 |
public interface Animal { static void info() { System.out.println("This is an animal interface"); } } |
- Constants: All fields declared inside an interface are implicitly
public,static, andfinal. So, interfaces are commonly used for defining constants.
|
1 2 3 |
public interface Animal { int MAX_AGE = 100; // constant } |
Real-World Example
Let’s say you’re building an online payment system, and you want to support multiple payment methods like credit cards, PayPal, and cryptocurrencies. You could define an interface like this:
|
1 2 3 |
public interface Payment { void makePayment(double amount); } |
Then, you can implement different classes for each payment method:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class CreditCardPayment implements Payment { public void makePayment(double amount) { System.out.println("Payment of $" + amount + " made using Credit Card"); } } public class PayPalPayment implements Payment { public void makePayment(double amount) { System.out.println("Payment of $" + amount + " made using PayPal"); } } public class CryptoPayment implements Payment { public void makePayment(double amount) { System.out.println("Payment of $" + amount + " made using Cryptocurrency"); } } |
Now, the client code can work with any type of payment method through the Payment interface:
|
1 2 3 4 5 |
public class PaymentProcessor { public void processPayment(Payment paymentMethod, double amount) { paymentMethod.makePayment(amount); } } |
