https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Item 22: Java Best Practices - Use interfaces only to define types
Introduction to Using Interfaces to Define Types in [[Java]]
Defining Types with Interfaces
Advantages of Using Interfaces for Types Only
Example 1: Defining a Simple Type with an Interface
Avoiding Implementation in Interfaces
Example 2: Avoiding Default Methods in Interfaces
Ensuring Single Responsibility
Example 3: Interface as a Pure Type Definition
Interface Segregation Principle (ISP)
Avoiding Bloated Interfaces
Promoting Polymorphism with Type-Defining Interfaces
Maintaining Flexibility and Extensibility
Conclusion
Further Reading and References
Fair Use Sources
Java Vocabulary List (Sorted by Popularity)

Item 22: Java Best Practices - Use interfaces only to define types

Return to Effective Java, Java Best Practices, Java Style Guides, Java

Introduction to Using Interfaces to Define Types in [[Java]]

In Java, interfaces are a powerful tool used to define contracts that classes can implement. However, a best practice is to use interfaces solely to define types rather than as a means to provide implementation or behavior. This approach promotes clear, maintainable code and ensures that interfaces serve their intended purpose—defining what a class can do, rather than how it does it.

Defining Types with Interfaces

The primary purpose of an interface in Java is to define a type that classes can implement. By defining a type, an interface allows different classes to be treated uniformly in contexts that expect that type. This is fundamental to polymorphism in Java, where different objects can be interacted with through a common interface without needing to know their specific class.

Advantages of Using Interfaces for Types Only

When interfaces are used exclusively to define types, it results in a cleaner and more understandable codebase. This practice ensures that the interface clearly specifies what capabilities a class must provide without dictating how those capabilities are implemented. This separation of concerns leads to more flexible and reusable code, as the implementation details can vary widely while still adhering to the same interface.

Example 1: Defining a Simple Type with an Interface

Consider an interface `Flyable` that defines a type for any object that can fly:

```java public interface Flyable {

   void fly();

} ```

This interface defines a type `Flyable`, which can be implemented by any class that needs to provide flying behavior. Importantly, the interface does not impose any restrictions or offer any implementations on how the flying should be done, leaving that up to the implementing class.

Avoiding Implementation in Interfaces

While Java 8 introduced default methods that allow interfaces to provide method implementations, it is generally advisable to avoid using interfaces for providing behavior. Default methods can lead to confusion and can make the interface harder to understand and maintain, as it begins to blur the line between interface and abstract class.

Example 2: Avoiding Default Methods in Interfaces

Here’s an example where default methods are avoided in favor of keeping the interface purely as a type definition:

```java public interface Drawable {

   void draw();

} ```

By keeping the `Drawable` interface focused solely on defining the type, any class that implements it is free to define how the drawing should be done, without being influenced by a default method that might not be suitable for all implementations.

Ensuring Single Responsibility

Using interfaces solely to define types adheres to the Single Responsibility Principle, one of the core principles of object-oriented design. This principle states that a class or interface should have only one reason to change. When interfaces are used only to define types, they adhere to this principle by focusing exclusively on defining what a class can do, without getting involved in how it does it.

Example 3: Interface as a Pure Type Definition

Consider an interface `Storable` that defines a type for objects that can be stored:

```java public interface Storable {

   void store();

} ```

This interface adheres to the Single Responsibility Principle by focusing solely on the type definition, leaving the storage mechanism entirely up to the implementing classes.

Interface Segregation Principle (ISP)

The Interface Segregation Principle (ISP) is another key design principle that aligns with using interfaces to define types. ISP suggests that clients should not be forced to depend on interfaces they do not use. By keeping interfaces small and focused on specific types, you ensure that implementing classes only need to adhere to the contracts that are relevant to them.

Avoiding Bloated Interfaces

One of the risks of not following this best practice is ending up with bloated interfaces—interfaces that define too many methods, some of which might not be applicable to all implementing classes. This violates the Interface Segregation Principle and leads to more complex and less maintainable code. By using interfaces strictly to define types, you avoid this pitfall and keep your interfaces clean and focused.

Promoting Polymorphism with Type-Defining Interfaces

Interfaces that define types play a critical role in promoting polymorphism in Java. Polymorphism allows objects of different classes to be treated as instances of the same type. By defining clear, type-focused interfaces, you enable your code to interact with different implementations in a consistent and predictable manner, without needing to know the specifics of each implementation.

Maintaining Flexibility and Extensibility

Using interfaces purely to define types also enhances the flexibility and extensibility of your code. Because the interface only defines what the implementing classes must do, new classes can be added that implement the interface in different ways without requiring changes to the interface itself. This allows your codebase to evolve and grow without introducing breaking changes.

Conclusion

In conclusion, using interfaces in Java solely to define types is a best practice that promotes clear, maintainable, and flexible code. By focusing interfaces on what a class must do rather than how it does it, you adhere to important design principles such as the Single Responsibility Principle and the Interface Segregation Principle. This approach leads to a cleaner, more understandable codebase that can easily adapt to future requirements.