Abstract Classes Vs Interfaces - Learning Module

Loading content...

0/246

When to Use Interfaces

The Power of Pure Contracts

In the previous page, we established when abstract classes are the right choice. Now we examine the complementary question: When should you choose an interface?

Interfaces offer something abstract classes cannot: complete separation between contract and implementation. This separation is foundational to many modern architectural patterns, testing strategies, and extensibility mechanisms.

Understanding when interfaces are superior to abstract classes is crucial for building systems that are flexible, testable, and resilient to change.

What You Will Learn

By the end of this page, you will have a decision framework for choosing interfaces. You'll understand the specific scenarios where interfaces provide irreplaceable value, from multiple implementation needs to testability to architectural boundaries.

The Interface Decision Framework

Choose an interface when:

Multiple implementations exist or are expected — Different providers, strategies, or backends
You need testability via substitution — Mock/stub/fake implementations for testing
You're defining a capability, not an identity — CAN-DO rather than IS-A
Multiple inheritance is needed — A type must fulfill multiple unrelated contracts
You want loose coupling — Consumers shouldn't know about implementation details
You're defining API boundaries — Between modules, layers, or services

If you need substantial shared implementation, protected member access, or template algorithms—reconsider abstract classes. Otherwise, interfaces are often the more flexible choice.

Interface vs Abstract Class Quick Decision
Question	Yes → Interface	No → Abstract Class
Are there multiple implementations?	Define capability via interface	Single implementation may not need abstraction
Do you need to mock for testing?	Interface enables substitution	Concrete class may suffice for unit
Is it a capability, not identity?	CAN-DO → Interface	IS-A → Abstract class
Does type need multiple contracts?	Interfaces compose	Single inheritance limits abstract classes
Different teams build implementations?	Interface is the contract	Shared code needs coordination

Default to Interfaces

When in doubt, start with an interface. You can always introduce an abstract class later if shared implementation needs arise. Going the other direction—extracting an interface from an abstract class—is harder because consumers may already depend on concrete implementation details.

Criterion 1: Multiple Implementations

The most common reason to use an interface is multiple implementations. When you have—or anticipate—different ways to provide the same capability, an interface is the natural abstraction.

Real-World Examples:

Storage: Files could live in S3, GCS, Azure Blob, or local filesystem
Payments: Transactions could go through Stripe, PayPal, Square, or Adyen
Notifications: Alerts could be sent via Email, SMS, Push, or Slack
Databases: Repository could use PostgreSQL, MySQL, MongoDB, or in-memory
Cache: Data could be cached in Redis, Memcached, or local memory

In each case, the consumer doesn't care which implementation is used—they care only that the capability exists.

MultipleImplementations.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
// ═══════════════════════════════════════════════════
// INTERFACE: Defines what ALL storage providers must do
// ═══════════════════════════════════════════════════
 
public interface ObjectStorage {
    
    /**
     * Upload an object to storage.
     * @return URL or identifier for the stored object
     */
    String upload(String key, byte[] content, ContentType contentType);
    
    /**
     * Download an object from storage.
     * @return The object content, or empty if not found
     */
    Optional<byte[]> download(String key);
    
    /**
     * Delete an object from storage.
     * @return true if deletion succeeded
     */
    boolean delete(String key);
    
    /**
     * Check if an object exists.
     */
    boolean exists(String key);
    
    /**
     * Get a pre-signed URL for direct access (e.g., for browser downloads).
     * @param expirationMinutes How long the URL should be valid
     */
    String getSignedUrl(String key, int expirationMinutes);
    
    /**
     * List objects with a given prefix.
     */
    List<StoredObject> list(String prefix, int limit);
}
 
 
// ═══════════════════════════════════════════════════
// IMPLEMENTATION 1: Amazon S3
// ═══════════════════════════════════════════════════
 
public class S3ObjectStorage implements ObjectStorage {
    
    private final S3Client s3;
    private final String bucket;
    
    public S3ObjectStorage(S3Client s3, String bucket) {
        this.s3 = s3;
        this.bucket = bucket;
    }
    
    @Override
    public String upload(String key, byte[] content, ContentType contentType) {
        s3.putObject(
            PutObjectRequest.builder()
                .bucket(bucket)
                .key(key)
                .contentType(contentType.getMimeType())
                .build(),
            RequestBody.fromBytes(content)
        );
        return String.format("s3://%s/%s", bucket, key);
    }
    
    @Override
    public Optional<byte[]> download(String key) {
        try {
            ResponseBytes<GetObjectResponse> response = s3.getObjectAsBytes(
                GetObjectRequest.builder()
                    .bucket(bucket)
                    .key(key)
                    .build()
            );
            return Optional.of(response.asByteArray());
        } catch (NoSuchKeyException e) {
            return Optional.empty();
        }
    }
    
    @Override
    public String getSignedUrl(String key, int expirationMinutes) {
        S3Presigner presigner = S3Presigner.create();
        GetObjectPresignRequest request = GetObjectPresignRequest.builder()
            .signatureDuration(Duration.ofMinutes(expirationMinutes))
            .getObjectRequest(r -> r.bucket(bucket).key(key))
            .build();
        return presigner.presignGetObject(request).url().toString();
    }
    
    // ... other implementations
}
 
 
// ═══════════════════════════════════════════════════
// IMPLEMENTATION 2: Google Cloud Storage
// ═══════════════════════════════════════════════════
 
public class GcsObjectStorage implements ObjectStorage {
    
    private final Storage storage;
    private final String bucket;
    
    public GcsObjectStorage(Storage storage, String bucket) {
        this.storage = storage;
        this.bucket = bucket;
    }
    
    @Override
    public String upload(String key, byte[] content, ContentType contentType) {
        BlobId blobId = BlobId.of(bucket, key);
        BlobInfo blobInfo = BlobInfo.newBuilder(blobId)
            .setContentType(contentType.getMimeType())
            .build();
        storage.create(blobInfo, content);
        return String.format("gs://%s/%s", bucket, key);
    }
    
    @Override
    public Optional<byte[]> download(String key) {
        Blob blob = storage.get(BlobId.of(bucket, key));
        if (blob == null) {
            return Optional.empty();
        }
        return Optional.of(blob.getContent());
    }
    
    @Override
    public String getSignedUrl(String key, int expirationMinutes) {
        BlobInfo blobInfo = BlobInfo.newBuilder(BlobId.of(bucket, key)).build();
        URL url = storage.signUrl(
            blobInfo,
            expirationMinutes,
            TimeUnit.MINUTES,
            Storage.SignUrlOption.withV4Signature()
        );
        return url.toString();
    }
    
    // ... other implementations
}
 
 
// ═══════════════════════════════════════════════════
// IMPLEMENTATION 3: Local Filesystem (for development)
// ═══════════════════════════════════════════════════
 
public class LocalFileStorage implements ObjectStorage {
    
    private final Path basePath;
    private final String baseUrl;
    
    public LocalFileStorage(Path basePath, String baseUrl) {
        this.basePath = basePath;
        this.baseUrl = baseUrl;
    }
    
    @Override
    public String upload(String key, byte[] content, ContentType contentType) {
        try {
            Path filePath = basePath.resolve(key);
            Files.createDirectories(filePath.getParent());
            Files.write(filePath, content);
            return baseUrl + "/" + key;
        } catch (IOException e) {
            throw new StorageException("Failed to write file", e);
        }
    }
    
    @Override
    public Optional<byte[]> download(String key) {
        try {
            Path filePath = basePath.resolve(key);
            if (!Files.exists(filePath)) {
                return Optional.empty();
            }
            return Optional.of(Files.readAllBytes(filePath));
        } catch (IOException e) {
            throw new StorageException("Failed to read file", e);
        }
    }
    
    @Override
    public String getSignedUrl(String key, int expirationMinutes) {
        // Local storage doesn't support signed URLs
        // Just return the direct URL
        return baseUrl + "/" + key;
    }
    
    // ... other implementations
}
 
 
// ═══════════════════════════════════════════════════
// CONSUMER: Uses interface, agnostic to implementation
// ═══════════════════════════════════════════════════
 
public class FileUploadService {
    
    private final ObjectStorage storage;  // Interface dependency
    
    // Implementation injected - service doesn't know or care which one
    public FileUploadService(ObjectStorage storage) {
        this.storage = storage;
    }
    
    public UploadResult uploadUserAvatar(String userId, MultipartFile file) {
        String key = "avatars/" + userId + "/" + generateUniqueId() + 
                     getExtension(file.getOriginalFilename());
        
        String url = storage.upload(key, file.getBytes(), file.getContentType());
        
        return new UploadResult(key, url);
    }
    
    public byte[] downloadFile(String key) {
        return storage.download(key)
            .orElseThrow(() -> new FileNotFoundException("File not found: " + key));
    }
}

Runtime Flexibility

With interface-based design, implementation selection can happen at runtime via configuration. Development uses LocalFileStorage, staging uses GcsObjectStorage, production uses S3ObjectStorage—all without changing the FileUploadService code.

Criterion 2: Testability Via Substitution

Interfaces are essential for unit testing. When your code depends on an interface, you can substitute a test double (mock, stub, fake) for the real implementation—enabling isolated, fast, and deterministic tests.

Why This Matters:

Isolation: Test one unit without its dependencies (database, external APIs)
Speed: No network calls, disk I/O, or database queries
Determinism: Control exactly what dependencies return—no flaky tests
Coverage: Simulate error conditions that are hard to trigger in reality
Cost: Avoid real charges (SMS, payment processing, cloud usage)

TestabilityExample.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
// ═══════════════════════════════════════════════════
// INTERFACE: Contract for external API calls
// ═══════════════════════════════════════════════════
 
public interface WeatherService {
    WeatherData getCurrentWeather(String city);
    List<WeatherData> getForecast(String city, int days);
    boolean isApiHealthy();
}
 
 
// ═══════════════════════════════════════════════════
// PRODUCTION IMPLEMENTATION: Real API calls
// ═══════════════════════════════════════════════════
 
public class OpenWeatherMapService implements WeatherService {
    
    private final HttpClient httpClient;
    private final String apiKey;
    
    @Override
    public WeatherData getCurrentWeather(String city) {
        // Real HTTP call to OpenWeatherMap API
        String url = String.format(
            "https://api.openweathermap.org/data/2.5/weather?q=%s&appid=%s",
            city, apiKey
        );
        
        HttpResponse response = httpClient.get(url);
        return parseWeatherResponse(response.getBody());
    }
    
    // Real network latency, real API quotas, real costs
}
 
 
// ═══════════════════════════════════════════════════
// SERVICE UNDER TEST: Uses WeatherService interface
// ═══════════════════════════════════════════════════
 
public class TravelRecommendationService {
    
    private final WeatherService weatherService;  // Interface dependency
    private final DestinationRepository destinations;
    
    public TravelRecommendationService(
        WeatherService weatherService,
        DestinationRepository destinations
    ) {
        this.weatherService = weatherService;
        this.destinations = destinations;
    }
    
    public List<Recommendation> getRecommendations(TravelPreferences prefs) {
        List<Recommendation> recommendations = new ArrayList<>();
        
        for (Destination destination : destinations.findAll()) {
            WeatherData weather = weatherService.getCurrentWeather(
                destination.getCity()
            );
            
            if (matchesPreferences(weather, prefs)) {
                double score = calculateScore(destination, weather, prefs);
                recommendations.add(new Recommendation(destination, score));
            }
        }
        
        recommendations.sort(Comparator.comparing(Recommendation::getScore).reversed());
        return recommendations.subList(0, Math.min(10, recommendations.size()));
    }
    
    public ServiceStatus getStatus() {
        boolean weatherHealthy = weatherService.isApiHealthy();
        return new ServiceStatus(weatherHealthy);
    }
    
    private boolean matchesPreferences(WeatherData weather, TravelPreferences prefs) {
        return weather.getTemperature() >= prefs.getMinTemp()
            && weather.getTemperature() <= prefs.getMaxTemp()
            && (!prefs.isAvoidRain() || !weather.isRaining());
    }
}
 
 
// ═══════════════════════════════════════════════════
// TEST DOUBLE: Fake implementation for testing
// ═══════════════════════════════════════════════════
 
public class FakeWeatherService implements WeatherService {
    
    private final Map<String, WeatherData> weatherByCity = new HashMap<>();
    private boolean healthy = true;
    private int callCount = 0;
    
    // Test setup: Configure what weather data to return
    public void setWeatherFor(String city, WeatherData data) {
        weatherByCity.put(city.toLowerCase(), data);
    }
    
    public void setHealthy(boolean healthy) {
        this.healthy = healthy;
    }
    
    @Override
    public WeatherData getCurrentWeather(String city) {
        callCount++;
        WeatherData data = weatherByCity.get(city.toLowerCase());
        if (data == null) {
            throw new CityNotFoundException("Unknown city: " + city);
        }
        return data;
    }
    
    @Override
    public boolean isApiHealthy() {
        return healthy;
    }
    
    // Test verification: Check interactions
    public int getCallCount() {
        return callCount;
    }
    
    public void reset() {
        weatherByCity.clear();
        callCount = 0;
        healthy = true;
    }
}
 
 
// ═══════════════════════════════════════════════════
// UNIT TESTS: Fast, isolated, deterministic
// ═══════════════════════════════════════════════════
 
class TravelRecommendationServiceTest {
    
    private FakeWeatherService fakeWeatherService;
    private InMemoryDestinationRepository fakeRepository;
    private TravelRecommendationService service;
    
    @BeforeEach
    void setUp() {
        fakeWeatherService = new FakeWeatherService();
        fakeRepository = new InMemoryDestinationRepository();
        service = new TravelRecommendationService(fakeWeatherService, fakeRepository);
    }
    
    @Test
    void recommendsDestinationsMatchingTemperaturePreference() {
        // Arrange: Set up test data
        fakeRepository.save(new Destination("Paris", "France"));
        fakeRepository.save(new Destination("Miami", "USA"));
        fakeRepository.save(new Destination("Reykjavik", "Iceland"));
        
        fakeWeatherService.setWeatherFor("Paris", 
            new WeatherData(20, false));  // 20°C, not raining
        fakeWeatherService.setWeatherFor("Miami", 
            new WeatherData(32, false));  // 32°C, not raining  
        fakeWeatherService.setWeatherFor("Reykjavik", 
            new WeatherData(5, true));    // 5°C, raining
        
        TravelPreferences prefs = TravelPreferences.builder()
            .minTemp(15)
            .maxTemp(25)
            .avoidRain(true)
            .build();
        
        // Act
        List<Recommendation> results = service.getRecommendations(prefs);
        
        // Assert
        assertEquals(1, results.size());
        assertEquals("Paris", results.get(0).getDestination().getCity());
    }
    
    @Test
    void handlesWeatherApiUnavailable() {
        // Arrange: Simulate API failure
        fakeWeatherService.setHealthy(false);
        
        // Act
        ServiceStatus status = service.getStatus();
        
        // Assert
        assertFalse(status.isWeatherApiHealthy());
    }
    
    @Test
    void handlesUnknownCity() {
        // Arrange: City not in fake data
        fakeRepository.save(new Destination("Atlantis", "Ocean"));
        // Note: No weather data set for Atlantis
        
        TravelPreferences prefs = TravelPreferences.defaultPrefs();
        
        // Act & Assert: Should handle gracefully
        assertThrows(
            CityNotFoundException.class,
            () -> service.getRecommendations(prefs)
        );
    }
}

The Testability Heuristic

If you're writing 'new RealDependency()' inside a class, that class is hard to test. Extract an interface for the dependency and inject it via constructor. Now tests can inject fakes, and production code can inject real implementations. This simple pattern—Interface + Dependency Injection—is the foundation of testable design.

Criterion 3: Multiple Inheritance of Contracts

Unlike classes (which typically allow only single inheritance), interfaces support multiple inheritance. A class can implement any number of interfaces, acquiring multiple capabilities simultaneously.

This enables capability composition—building complex types by combining simple, focused contracts without inheritance hierarchy complexity.

MultipleInheritance.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
// ═══════════════════════════════════════════════════
// FOCUSED INTERFACES: Each defines ONE capability
// ═══════════════════════════════════════════════════
 
// Can persist to database
public interface Persistable {
    void save();
    void delete();
    boolean isPersisted();
}
 
// Can be serialized to JSON
public interface JsonSerializable {
    String toJson();
    void fromJson(String json);
}
 
// Can be compared for equality and ordering
public interface Comparable<T> {
    int compareTo(T other);
}
 
// Can be validated before use
public interface Validatable {
    List<ValidationError> validate();
    default boolean isValid() {
        return validate().isEmpty();
    }
}
 
// Can be cloned/copied
public interface Cloneable<T> {
    T deepClone();
}
 
// Can be cached with TTL semantics
public interface Cacheable {
    String getCacheKey();
    Duration getTimeToLive();
    default boolean shouldCache() {
        return true;
    }
}
 
// Has audit trail
public interface Auditable {
    String getCreatedBy();
    Instant getCreatedAt();
    String getLastModifiedBy();
    Instant getLastModifiedAt();
}
 
 
// ═══════════════════════════════════════════════════
// DOMAIN OBJECT: Implements MULTIPLE interfaces
// ═══════════════════════════════════════════════════
 
public class Product implements 
    Persistable, 
    JsonSerializable, 
    Comparable<Product>,
    Validatable, 
    Cloneable<Product>,
    Cacheable, 
    Auditable {
    
    private Long id;
    private String sku;
    private String name;
    private Money price;
    private int stockQuantity;
    private ProductStatus status;
    
    // Audit fields
    private String createdBy;
    private Instant createdAt;
    private String lastModifiedBy;
    private Instant lastModifiedAt;
    
    // ─────────────────────────────────────────────────
    // Persistable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public void save() {
        // Delegate to repository (would be injected in real code)
        ProductRepository.getInstance().save(this);
    }
    
    @Override
    public void delete() {
        ProductRepository.getInstance().delete(this.id);
    }
    
    @Override
    public boolean isPersisted() {
        return this.id != null;
    }
    
    // ─────────────────────────────────────────────────
    // JsonSerializable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public String toJson() {
        return new ObjectMapper().writeValueAsString(this);
    }
    
    @Override
    public void fromJson(String json) {
        Product parsed = new ObjectMapper().readValue(json, Product.class);
        this.sku = parsed.sku;
        this.name = parsed.name;
        // ... copy other fields
    }
    
    // ─────────────────────────────────────────────────
    // Comparable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public int compareTo(Product other) {
        // Sort by SKU for consistent ordering
        return this.sku.compareTo(other.sku);
    }
    
    // ─────────────────────────────────────────────────
    // Validatable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public List<ValidationError> validate() {
        List<ValidationError> errors = new ArrayList<>();
        
        if (sku == null || sku.isBlank()) {
            errors.add(new ValidationError("sku", "SKU is required"));
        }
        if (name == null || name.length() < 3) {
            errors.add(new ValidationError("name", "Name must be at least 3 characters"));
        }
        if (price == null || price.isNegativeOrZero()) {
            errors.add(new ValidationError("price", "Price must be positive"));
        }
        if (stockQuantity < 0) {
            errors.add(new ValidationError("stockQuantity", "Stock cannot be negative"));
        }
        
        return errors;
    }
    
    // ─────────────────────────────────────────────────
    // Cloneable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public Product deepClone() {
        Product clone = new Product();
        clone.sku = this.sku + "-COPY";
        clone.name = this.name;
        clone.price = this.price; // Money is immutable
        clone.stockQuantity = this.stockQuantity;
        clone.status = this.status;
        // Note: id is null (not persisted), audit fields reset
        return clone;
    }
    
    // ─────────────────────────────────────────────────
    // Cacheable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public String getCacheKey() {
        return "product:" + this.sku;
    }
    
    @Override
    public Duration getTimeToLive() {
        // Hot products cached longer
        return status == ProductStatus.FEATURED 
            ? Duration.ofHours(1) 
            : Duration.ofMinutes(15);
    }
    
    // ─────────────────────────────────────────────────
    // Auditable implementation
    // ─────────────────────────────────────────────────
    
    @Override
    public String getCreatedBy() { return createdBy; }
    
    @Override
    public Instant getCreatedAt() { return createdAt; }
    
    @Override
    public String getLastModifiedBy() { return lastModifiedBy; }
    
    @Override
    public Instant getLastModifiedAt() { return lastModifiedAt; }
}
 
 
// ═══════════════════════════════════════════════════
// SERVICES: Depend on specific capabilities
// ═══════════════════════════════════════════════════
 
// Cache service cares about Cacheable
public class CacheService {
    private final Cache cache;
    
    public <T extends Cacheable> void cache(T item) {
        cache.put(item.getCacheKey(), item, item.getTimeToLive());
    }
}
 
// Audit service cares about Auditable
public class AuditService {
    public void logChange(Auditable entity, String action) {
        log.info("Action {} on entity at {} by {}",
            action,
            entity.getLastModifiedAt(),
            entity.getLastModifiedBy()
        );
    }
}
 
// Validation service cares about Validatable
public class ValidationService {
    public void ensureValid(Validatable entity) {
        List<ValidationError> errors = entity.validate();
        if (!errors.isEmpty()) {
            throw new ValidationException(errors);
        }
    }
}
 
// Export service cares about JsonSerializable
public class ExportService {
    public void exportToFile(List<? extends JsonSerializable> items, Path path) {
        List<String> jsonLines = items.stream()
            .map(JsonSerializable::toJson)
            .toList();
        Files.write(path, jsonLines);
    }
}

Interface Segregation in Action

Notice how each service depends only on the interface it needs. CacheService doesn't know Product is Auditable; AuditService doesn't know Product is Cacheable. This is Interface Segregation Principle: clients depend only on methods they use, achieved through multiple focused interfaces.

Criterion 4: Defining Architectural Boundaries

Interfaces are the primary tool for defining architectural boundaries—the contracts between layers, modules, and services. They specify what one part of the system provides to another without coupling either to implementation details.

Common Boundary Patterns:

Layer Boundaries: Interfaces between presentation, domain, and infrastructure
Module Boundaries: Interfaces for inter-module communication
Service Boundaries: API definitions between microservices
External System Adapters: Interfaces abstracting third-party systems

ArchitecturalBoundaries.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
// ═══════════════════════════════════════════════════
// HEXAGONAL ARCHITECTURE: Ports define boundaries
// ═══════════════════════════════════════════════════
 
// ── DOMAIN LAYER: Pure business logic ──────────────
 
// The domain defines what it NEEDS (driven ports/interfaces)
package com.app.domain.ports.outbound;
 
// Domain needs to persist orders
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomer(CustomerId customerId);
}
 
// Domain needs to send notifications
public interface NotificationPort {
    void sendOrderConfirmation(Order order);
    void sendShippingUpdate(Order order, ShippingStatus status);
}
 
// Domain needs to process payments
public interface PaymentPort {
    PaymentResult processPayment(Order order, PaymentDetails payment);
    RefundResult refundPayment(String transactionId, Money amount);
}
 
// Domain needs to check inventory
public interface InventoryPort {
    boolean checkAvailability(ProductId productId, int quantity);
    void reserveStock(ProductId productId, int quantity);
    void releaseStock(ProductId productId, int quantity);
}
 
 
// Domain also defines what it PROVIDES (driving ports)
package com.app.domain.ports.inbound;
 
// OrderService is the entry point for order operations
public interface OrderService {
    OrderId createOrder(CreateOrderCommand command);
    void addItem(OrderId orderId, AddItemCommand command);
    void submit(OrderId orderId);
    void cancel(OrderId orderId);
    OrderDto getOrder(OrderId orderId);
}
 
 
// Domain implementation (core business logic)
package com.app.domain.services;
 
public class OrderServiceImpl implements OrderService {
    
    // Depends on INTERFACES (ports), not implementations
    private final OrderRepository orderRepository;
    private final InventoryPort inventoryPort;
    private final PaymentPort paymentPort;
    private final NotificationPort notificationPort;
    
    public OrderServiceImpl(
        OrderRepository orderRepository,
        InventoryPort inventoryPort,
        PaymentPort paymentPort,
        NotificationPort notificationPort
    ) {
        this.orderRepository = orderRepository;
        this.inventoryPort = inventoryPort;
        this.paymentPort = paymentPort;
        this.notificationPort = notificationPort;
    }
    
    @Override
    public void submit(OrderId orderId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        // Business logic - pure domain
        order.validate();
        
        // Reserve inventory
        for (OrderItem item : order.getItems()) {
            inventoryPort.reserveStock(item.getProductId(), item.getQuantity());
        }
        
        // Process payment
        PaymentResult payment = paymentPort.processPayment(
            order, 
            order.getPaymentDetails()
        );
        
        if (!payment.isSuccessful()) {
            // Release reserved stock
            for (OrderItem item : order.getItems()) {
                inventoryPort.releaseStock(item.getProductId(), item.getQuantity());
            }
            throw new PaymentFailedException(payment.getError());
        }
        
        order.markSubmitted(payment.getTransactionId());
        orderRepository.save(order);
        
        // Send confirmation
        notificationPort.sendOrderConfirmation(order);
    }
}
 
 
// ── INFRASTRUCTURE LAYER: Implements ports ─────────
 
package com.app.infrastructure.persistence;
 
// JPA implementation of OrderRepository port
public class JpaOrderRepository implements OrderRepository {
    
    private final EntityManager em;
    private final OrderMapper mapper;
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        em.persist(entity);
    }
    
    @Override
    public Optional<Order> findById(OrderId id) {
        OrderEntity entity = em.find(OrderEntity.class, id.getValue());
        return Optional.ofNullable(entity).map(mapper::toDomain);
    }
}
 
 
package com.app.infrastructure.payment;
 
// Stripe implementation of PaymentPort
public class StripePaymentAdapter implements PaymentPort {
    
    private final StripeClient stripe;
    
    @Override
    public PaymentResult processPayment(Order order, PaymentDetails details) {
        // Stripe-specific API calls
        PaymentIntent intent = stripe.paymentIntents().create(
            PaymentIntentCreateParams.builder()
                .setAmount(order.getTotal().toCents())
                .setCurrency(order.getCurrency())
                .setPaymentMethod(details.getStripePaymentMethodId())
                .build()
        );
        
        return new PaymentResult(
            intent.getStatus().equals("succeeded"),
            intent.getId(),
            intent.getClientSecret()
        );
    }
}
 
 
package com.app.infrastructure.notification;
 
// SendGrid implementation of NotificationPort
public class SendGridNotificationAdapter implements NotificationPort {
    
    private final SendGrid sendGrid;
    private final EmailTemplates templates;
    
    @Override
    public void sendOrderConfirmation(Order order) {
        Email email = templates.orderConfirmation(order);
        sendGrid.send(email);
    }
}
 
 
// ── CONFIGURATION: Wires ports to adapters ─────────
 
package com.app.config;
 
@Configuration
public class DomainConfig {
    
    @Bean
    public OrderService orderService(
        OrderRepository orderRepository,
        InventoryPort inventoryPort,
        PaymentPort paymentPort,
        NotificationPort notificationPort
    ) {
        return new OrderServiceImpl(
            orderRepository,
            inventoryPort,
            paymentPort,
            notificationPort
        );
    }
}
 
@Configuration
public class InfrastructureConfig {
    
    @Bean
    public OrderRepository orderRepository(EntityManager em) {
        return new JpaOrderRepository(em);
    }
    
    @Bean
    @Profile("production")
    public PaymentPort paymentPort(StripeClient stripe) {
        return new StripePaymentAdapter(stripe);
    }
    
    @Bean
    @Profile("test")
    public PaymentPort testPaymentPort() {
        return new MockPaymentAdapter(); // For testing
    }
}

Ports and Adapters

In Hexagonal Architecture, interfaces are 'ports' (what the domain needs/provides) and implementations are 'adapters' (how infrastructure fulfills those needs). The domain is the center—it defines ports. Infrastructure adapts to those ports. This keeps domain logic pure and infrastructure concerns swappable.

Criterion 5: Defining Capabilities, Not Identities

Interfaces are ideal for CAN-DO relationships—when you're defining what a type can do rather than what it is.

The Distinction:

IS-A (Identity): "A Dog IS AN Animal." Shared essence. Use inheritance/abstract class.
CAN-DO (Capability): "A Dog CAN BE walked." Shared behavior. Use interface.

Many types from different hierarchies can share a capability. A Robot, a Dog, and a Human can all implement Walkable—but they have no shared identity. They just share what they can do.

CAN-DO → Interface

•Entity CAN BE serialized → Serializable
•Collection CAN BE iterated → Iterable
•Resource CAN BE closed → Closeable
•Job CAN BE run → Runnable
•Event CAN BE handled → EventHandler
•Document CAN BE printed → Printable

IS-A → Abstract Class

•Dog IS A Pet → Pet abstract class
•Triangle IS A Shape → Shape abstract class
•CheckingAccount IS A BankAccount → BankAccount abstract class
•HttpException IS A Exception → Exception hierarchy
•Button IS A UIComponent → UIComponent abstract class

CanDoRelationships.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// ═══════════════════════════════════════════════════
// CAPABILITY INTERFACES: Diverse types share behaviors
// ═══════════════════════════════════════════════════
 
// Anything that can be rendered to a display
public interface Renderable {
    void render(Canvas canvas);
    Rectangle getBoundingBox();
}
 
// Implementation: Game entities
public class Player implements Renderable {
    @Override
    public void render(Canvas canvas) {
        canvas.drawSprite(playerSprite, x, y);
    }
}
 
// Implementation: UI elements
public class HealthBar implements Renderable {
    @Override
    public void render(Canvas canvas) {
        canvas.drawRect(x, y, width * healthPercent, height, Color.GREEN);
    }
}
 
// Implementation: Effects
public class Explosion implements Renderable {
    @Override
    public void render(Canvas canvas) {
        canvas.drawAnimation(explosionFrames, x, y, currentFrame);
    }
}
 
// Rendering system doesn't care WHAT things are
// Only that they CAN BE rendered
public class RenderingEngine {
    
    private final List<Renderable> renderables;
    
    public void renderFrame(Canvas canvas) {
        // Sort by z-order for proper layering
        renderables.stream()
            .sorted(Comparator.comparing(r -> r.getBoundingBox().getZ()))
            .forEach(r -> r.render(canvas));
    }
}
 
 
// ═══════════════════════════════════════════════════
// MORE EXAMPLES: Diverse types, shared capability
// ═══════════════════════════════════════════════════
 
// Anything that can be scheduled
public interface Schedulable {
    void execute();
    Instant getScheduledTime();
    Duration getRetryDelay();
    int getMaxRetries();
}
 
// Implementation: Email campaigns
public class EmailCampaign implements Schedulable { ... }
 
// Implementation: Report generation
public class ReportJob implements Schedulable { ... }
 
// Implementation: Data cleanup
public class DataPurgeTask implements Schedulable { ... }
 
// Implementation: External API sync
public class ApiSyncJob implements Schedulable { ... }
 
 
// Scheduler doesn't care what it's scheduling
// Only that items CAN BE scheduled
public class JobScheduler {
    
    public void schedule(Schedulable job) {
        queue.addAt(job.getScheduledTime(), job);
    }
    
    public void processQueue() {
        while (true) {
            Schedulable next = queue.pollNext();
            try {
                next.execute();
            } catch (Exception e) {
                if (next.getMaxRetries() > 0) {
                    reschedule(next);
                }
            }
        }
    }
}

The Litmus Test

When modeling, ask: Does 'X CAN Y' make sense, or does 'X IS A Y' make sense? If a Player 'IS A Renderable' sounds odd but 'CAN BE rendered' sounds right—use an interface. If a Dog 'IS A Pet' makes sense—consider an abstract class or inheritance.

Summary: When to Choose Interfaces

We've established comprehensive criteria for choosing interfaces. Let's consolidate the decision framework:

Choose Interface When

•Multiple implementations exist — Different providers, strategies, or backends need to fulfill the same contract.
•Testability is important — You need to substitute mocks/stubs/fakes for unit testing.
•Multiple contracts needed — A type must fulfill several unrelated capabilities (interface composition).
•Defining architectural boundaries — Contracts between layers, modules, or services.
•Modeling CAN-DO relationships — Types share capability but not identity.
•Maximum flexibility required — Implementations should be completely decoupled from consumers.

What's Next:

With clear understanding of when to use abstract classes and when to use interfaces, the final page explores modern interface features—particularly default methods—that blur traditional boundaries between these two abstractions.

Page Complete

You now have a complete framework for choosing interfaces: multiple implementations, testability, capability composition, architectural boundaries, and CAN-DO relationships. Next, we'll explore how modern languages have evolved interfaces with features like default methods.