Creative Ways to Use Interfaces in Java

Unconventional but Effective Ways to Use Interfaces in Java

Java developers often rely on traditional patterns like inheritance, abstract classes, and direct instantiation to structure their code. While these approaches are effective, they sometimes lead to rigid designs, unnecessary complexity, or reduced flexibility.

This article explores some unconventional but effective ways to use interfaces in Java. These techniques are not a replacement for traditional approaches but can offer significant advantages in specific scenarios.

Interface-Based Configuration (Strategy Pattern Enhancement)

Instead of using configuration files or enums for dynamic behaviour selection, use interfaces to encapsulate different configurations.

When to use it?

When you need to change behaviour dynamically based on configuration (e.g., selecting different caching strategies).

Issues with Traditional Alternative like Config Files or Enums:

• Configuration is often stored in properties files, YAML, JSON, or enums.
• Requires parsing, extra dependency management, or switch-case conditions to select behaviour.

Advantage of Interface-Based Configuration ?

• Encapsulates behaviour instead of just values.
• Avoids switch statements (cleaner, maintainable code).
• Allows dynamic behavior changes at runtime by swapping implementations.
• Enables testability by injecting different configuration implementations.

interface CacheConfig {
    int getSize();
    int getExpiration();
}

class ShortTermCache implements CacheConfig {
    public int getSize() { return 100; }
    public int getExpiration() { return 60; } // 60 seconds
}

class LongTermCache implements CacheConfig {
    public int getSize() { return 5000; }
    public int getExpiration() { return 3600; } // 1 hour
}

class CacheManager {
    private CacheConfig config;
    
    CacheManager(CacheConfig config) {
        this.config = config;
    }

    void printConfig() {
        System.out.println("Cache Size: " +…