Abstract Classes vs Interfaces

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

// Before Java 8: Adding forEach() would break all implementations
public interface Collection<E> {
    boolean add(E element);
    int size();
    Iterator<E> iterator();
    // Cannot add new methods without breaking all implementations!
}
 
 
// Java 8+: Default methods enable safe interface evolution
public interface Collection<E> {
    
    // Existing abstract methods - implementations must provide these
    boolean add(E element);
    int size();
    Iterator<E> iterator();
    
    // NEW: Default method with implementation
    // Existing implementations automatically get this behavior
    // They can override if they want, but don't have to
    default void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        for (E element : this) {
            action.accept(element);
        }
    }
    
    // Another default method added later
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        Iterator<E> iterator = iterator();
        while (iterator.hasNext()) {
            if (filter.test(iterator.next())) {
                iterator.remove();
                removed = true;
            }
        }
        return removed;
    }
    
    // And another - creating streams from collections
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}
 
 
// Existing implementation - UNCHANGED, still compiles and works
public class MyCustomList<E> implements Collection<E> {
    
    private Object[] elements;
    private int size;
    
    @Override
    public boolean add(E element) {
        ensureCapacity();
        elements[size++] = element;
        return true;
    }
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new MyListIterator();
    }
    
    // forEach(), removeIf(), stream() automatically work
    // using default implementations from Collection interface!
}
 
 
// Usage: Default methods just work
MyCustomList<String> list = new MyCustomList<>();
list.add("Hello");
list.add("World");
 
// This works! Uses default implementation
list.forEach(System.out::println);
 
// This works too!
list.removeIf(s -> s.length() < 5);
 
// And this!
list.stream().filter(s -> s.startsWith("H")).count();

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

// ═══════════════════════════════════════════════════
// RULE 1: Class methods always win
// ═══════════════════════════════════════════════════
 
interface Greeter {
    default String greet() {
        return "Hello from interface!";
    }
}
 
class FriendlyGreeter implements Greeter {
    // Class override wins over interface default
    @Override
    public String greet() {
        return "Hello from class!";
    }
}
 
// Result: "Hello from class!"
new FriendlyGreeter().greet();
 
 
// ═══════════════════════════════════════════════════
// RULE 2: More specific interface wins
// ═══════════════════════════════════════════════════
 
interface Vehicle {
    default String getDescription() {
        return "A vehicle";
    }
}
 
interface Car extends Vehicle {
    // More specific - this wins for Car implementations
    @Override
    default String getDescription() {
        return "A car";
    }
}
 
class Sedan implements Car {
    // Inherits Car's default, not Vehicle's
}
 
// Result: "A car"
new Sedan().getDescription();
 
 
// ═══════════════════════════════════════════════════
// RULE 3: Explicit resolution required for conflicts
// ═══════════════════════════════════════════════════
 
interface Flyable {
    default String move() {
        return "Flying";
    }
}
 
interface Swimmable {
    default String move() {
        return "Swimming";
    }
}
 
// This WON'T COMPILE - ambiguous!
// class Duck implements Flyable, Swimmable { }
 
// Must explicitly resolve the conflict
class Duck implements Flyable, Swimmable {
    
    @Override
    public String move() {
        // Option 1: Provide completely new implementation
        return "Waddling";
        
        // Option 2: Explicitly call one interface's default
        // return Flyable.super.move();
        
        // Option 3: Combine both
        // return Flyable.super.move() + " and " + Swimmable.super.move();
    }
}
 
 
// ═══════════════════════════════════════════════════
// Calling super interface defaults explicitly
// ═══════════════════════════════════════════════════
 
interface Logger {
    default void log(String message) {
        System.out.println("[LOG] " + message);
    }
}
 
interface TimestampedLogger extends Logger {
    @Override
    default void log(String message) {
        // Call parent interface's default implementation
        Logger.super.log(Instant.now() + " - " + message);
    }
}
 
class ConsoleLogger implements TimestampedLogger {
    @Override
    public void log(String message) {
        // Can call any interface's default in the hierarchy
        TimestampedLogger.super.log("[CONSOLE] " + message);
    }
}

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

// ═══════════════════════════════════════════════════
// USE CASE 1: Convenience methods using abstract methods
// ═══════════════════════════════════════════════════
 
public interface Repository<T, ID> {
    
    // Core abstract methods - implementations must provide
    Optional<T> findById(ID id);
    List<T> findAll();
    T save(T entity);
    void deleteById(ID id);
    
    // Convenience defaults built on abstract methods
    default boolean existsById(ID id) {
        return findById(id).isPresent();
    }
    
    default T findByIdOrThrow(ID id) {
        return findById(id)
            .orElseThrow(() -> new EntityNotFoundException(
                "Entity not found with id: " + id
            ));
    }
    
    default long count() {
        return findAll().size();
    }
    
    default boolean isEmpty() {
        return count() == 0;
    }
    
    default List<T> saveAll(Iterable<T> entities) {
        List<T> result = new ArrayList<>();
        for (T entity : entities) {
            result.add(save(entity));
        }
        return result;
    }
    
    default void deleteAll(Iterable<ID> ids) {
        for (ID id : ids) {
            deleteById(id);
        }
    }
}
 
 
// ═══════════════════════════════════════════════════
// USE CASE 2: Optional behavior with sensible defaults
// ═══════════════════════════════════════════════════
 
public interface EventHandler<T extends Event> {
    
    // Core method - must implement
    void handle(T event);
    
    // Optional: Filter which events to process
    // Default accepts all events
    default boolean shouldHandle(T event) {
        return true;
    }
    
    // Optional: Error handling strategy
    // Default just rethrows
    default void onError(T event, Exception e) {
        throw new EventHandlingException(
            "Failed to handle event: " + event.getId(), e
        );
    }
    
    // Optional: Post-processing
    // Default does nothing
    default void afterHandle(T event) {
        // No-op by default
    }
    
    // Optional: Specify handler order
    // Default is neutral priority
    default int getPriority() {
        return 0;
    }
}
 
// Simple implementation - only implements what it needs
class OrderCreatedHandler implements EventHandler<OrderCreatedEvent> {
    
    @Override
    public void handle(OrderCreatedEvent event) {
        // Core logic
        sendConfirmationEmail(event.getOrderId());
    }
    
    // Uses all defaults for optional methods
}
 
// Advanced implementation - customizes optional behavior
class AuditLogHandler implements EventHandler<Event> {
    
    private final AuditLog auditLog;
    
    @Override
    public void handle(Event event) {
        auditLog.record(event);
    }
    
    @Override
    public boolean shouldHandle(Event event) {
        // Only audit security-relevant events
        return event.getSecurityLevel().isAuditable();
    }
    
    @Override
    public void onError(Event event, Exception e) {
        // Log but don't fail
        logger.error("Audit failed for event: {}", event.getId(), e);
    }
    
    @Override
    public int getPriority() {
        // Run before other handlers
        return Integer.MAX_VALUE;
    }
}
 
 
// ═══════════════════════════════════════════════════
// USE CASE 3: Multi-inheritance of behavior
// ═══════════════════════════════════════════════════
 
interface Timestamped {
    Instant getCreatedAt();
    Instant getUpdatedAt();
    
    default boolean isNew() {
        return getCreatedAt() != null 
            && getCreatedAt().equals(getUpdatedAt());
    }
    
    default Duration getAge() {
        return Duration.between(getCreatedAt(), Instant.now());
    }
}
 
interface Identifiable<ID> {
    ID getId();
    
    default boolean isPersisted() {
        return getId() != null;
    }
}
 
interface SoftDeletable {
    Instant getDeletedAt();
    void setDeletedAt(Instant deletedAt);
    
    default boolean isDeleted() {
        return getDeletedAt() != null;
    }
    
    default void softDelete() {
        setDeletedAt(Instant.now());
    }
    
    default void restore() {
        setDeletedAt(null);
    }
}
 
// A class can inherit behavior from all three interfaces
class Article implements Identifiable<Long>, Timestamped, SoftDeletable {
    
    private Long id;
    private String title;
    private Instant createdAt;
    private Instant updatedAt;
    private Instant deletedAt;
    
    @Override
    public Long getId() { return id; }
    
    @Override
    public Instant getCreatedAt() { return createdAt; }
    
    @Override
    public Instant getUpdatedAt() { return updatedAt; }
    
    @Override
    public Instant getDeletedAt() { return deletedAt; }
    
    @Override
    public void setDeletedAt(Instant deletedAt) { 
        this.deletedAt = deletedAt; 
    }
    
    // Automatically has: isPersisted(), isNew(), getAge(), 
    //                    isDeleted(), softDelete(), restore()
}

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

// ═══════════════════════════════════════════════════
// SCENARIO: Why abstract class is still needed
// Default methods cannot manage state or construction
// ═══════════════════════════════════════════════════
 
// Interface with default methods - LIMITED
public interface CacheableService {
    
    // Default method - but cannot access any cache state!
    default Object getCached(String key) {
        // ERROR: Interfaces cannot have instance fields
        // return this.cache.get(key);
        
        // Can only call other interface methods
        return fetchFromSource(key);
    }
    
    Object fetchFromSource(String key);
}
 
 
// Abstract class can manage the cache properly
public abstract class AbstractCacheableService implements CacheableService {
    
    // Instance state - abstract class can have this
    private final Cache<String, Object> cache;
    private final Logger logger;
    
    // Constructor initializes state
    protected AbstractCacheableService(CacheConfig config) {
        this.cache = CacheBuilder.newBuilder()
            .maximumSize(config.getMaxSize())
            .expireAfterWrite(config.getTtl())
            .build();
        this.logger = LoggerFactory.getLogger(getClass());
    }
    
    // Can actually use the cache!
    public Object getCached(String key) {
        Object cached = cache.getIfPresent(key);
        if (cached != null) {
            logger.debug("Cache hit: {}", key);
            return cached;
        }
        
        logger.debug("Cache miss: {}", key);
        Object value = fetchFromSource(key);
        cache.put(key, value);
        return value;
    }
    
    // Protected method - only subclasses can call
    protected void invalidateCache(String key) {
        cache.invalidate(key);
        logger.debug("Invalidated: {}", key);
    }
    
    // Subclass implements the data source
    @Override
    public abstract Object fetchFromSource(String key);
}
 
 
// ═══════════════════════════════════════════════════
// THE HYBRID APPROACH: Interface + Abstract Class
// ═══════════════════════════════════════════════════
 
// Interface defines the contract with convenient defaults
public interface ResourceLoader {
    
    // Core method - must implement
    Resource load(String path) throws ResourceException;
    
    // Convenience defaults
    default Optional<Resource> loadOptional(String path) {
        try {
            return Optional.of(load(path));
        } catch (ResourceException e) {
            return Optional.empty();
        }
    }
    
    default boolean exists(String path) {
        return loadOptional(path).isPresent();
    }
    
    default List<Resource> loadAll(Collection<String> paths) {
        return paths.stream()
            .map(this::loadOptional)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toList());
    }
}
 
 
// Abstract class provides skeletal implementation with state
public abstract class AbstractResourceLoader implements ResourceLoader {
    
    // State that default methods can't have
    protected final ResourceCache cache;
    protected final Logger logger;
    private final ResourceMetrics metrics;
    
    protected AbstractResourceLoader(ResourceCache cache) {
        this.cache = cache;
        this.logger = LoggerFactory.getLogger(getClass());
        this.metrics = new ResourceMetrics();
    }
    
    // Template method with state management
    @Override
    public final Resource load(String path) throws ResourceException {
        // Check cache
        Resource cached = cache.get(path);
        if (cached != null) {
            metrics.recordCacheHit();
            return cached;
        }
        
        metrics.recordCacheMiss();
        
        // Delegate to subclass
        Resource resource = doLoad(path);
        
        // Cache result
        cache.put(path, resource);
        
        return resource;
    }
    
    // Subclass implements actual loading
    protected abstract Resource doLoad(String path) throws ResourceException;
}
 
 
// Concrete implementations can choose either base
// Option 1: Just implement interface (no shared state)
class SimpleFileLoader implements ResourceLoader {
    @Override
    public Resource load(String path) {
        return new FileResource(Paths.get(path));
    }
    // Gets default methods for free
}
 
 
// Option 2: Extend abstract class (get caching + state)
class CachedHttpLoader extends AbstractResourceLoader {
    
    private final HttpClient httpClient;
    
    public CachedHttpLoader(ResourceCache cache, HttpClient httpClient) {
        super(cache);
        this.httpClient = httpClient;
    }
    
    @Override
    protected Resource doLoad(String path) {
        // Only implement the core loading logic
        HttpResponse response = httpClient.get(path);
        return new HttpResource(response.getBody());
    }
    // Gets caching, logging, metrics for free
}

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

// ═══════════════════════════════════════════════════
// ANTI-PATTERN 1: Complex logic in default methods
// ═══════════════════════════════════════════════════
 
// BAD: Too much logic in interface
public interface OrderProcessor {
    Order getOrder();
    
    // Too complex for a default method!
    default ProcessingResult process() {
        Order order = getOrder();
        
        // Validate
        if (order.getItems().isEmpty()) {
            return ProcessingResult.failure("No items");
        }
        
        // Calculate totals
        BigDecimal subtotal = order.getItems().stream()
            .map(item -> item.getPrice().multiply(item.getQuantity()))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        // Apply discounts
        BigDecimal discount = BigDecimal.ZERO;
        if (order.hasPromoCode()) {
            discount = calculatePromoDiscount(order);
        }
        if (order.getCustomer().isMember()) {
            discount = discount.add(calculateMemberDiscount(order));
        }
        
        // Calculate tax
        BigDecimal taxable = subtotal.subtract(discount);
        BigDecimal tax = calculateTax(taxable, order.getShippingAddress());
        
        // Reserve inventory, process payment, update order...
        // This is WAY too much for a default method!
        
        return ProcessingResult.success();
    }
}
 
// BETTER: Simple defaults, complex logic in classes
public interface OrderProcessor {
    ProcessingResult process(Order order);
    
    // Simple convenience default
    default boolean canProcess(Order order) {
        return order != null && !order.getItems().isEmpty();
    }
}
 
 
// ═══════════════════════════════════════════════════
// ANTI-PATTERN 2: Simulating state with statics
// ═══════════════════════════════════════════════════
 
// BAD: Using statics to work around no-state limitation
public interface CountingProcessor {
    void process(Item item);
    
    // TERRIBLE: Static state shared by ALL implementations!
    AtomicInteger processedCount = new AtomicInteger(0);
    
    default void processWithCount(Item item) {
        process(item);
        processedCount.incrementAndGet(); // Shared mutable state!
    }
    
    default int getProcessedCount() {
        return processedCount.get(); // Same counter for everyone!
    }
}
 
// BETTER: Just use an abstract class if you need state
public abstract class CountingProcessor {
    private final AtomicInteger processedCount = new AtomicInteger(0);
    
    protected abstract void doProcess(Item item);
    
    public final void process(Item item) {
        doProcess(item);
        processedCount.incrementAndGet();
    }
    
    public int getProcessedCount() {
        return processedCount.get();
    }
}
 
 
// ═══════════════════════════════════════════════════
// ANTI-PATTERN 3: Breaking existing contract
// ═══════════════════════════════════════════════════
 
// Original interface
public interface Comparable<T> {
    int compareTo(T other);
}
 
// BAD: Adding default that changes contract semantics
public interface ComparableExtended<T> extends Comparable<T> {
    
    // This default changes behavior that clients depend on!
    @Override
    default int compareTo(T other) {
        // "Let's make null-safe by default"
        if (other == null) return 1;
        return compareNonNull(other);
    }
    
    int compareNonNull(T other);
}
 
// Problem: Existing code might depend on NPE for null!
// Collections.sort() might behave differently
// Comparator chains might break
// TreeSet/TreeMap invariants might be violated

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

// Kotlin: Interfaces can have properties and implementations
interface Identifiable {
    val id: String  // Abstract property
    
    // Default implementation
    fun getFormattedId(): String = "ID-$id"
}
 
interface Timestamped {
    val createdAt: Instant
    val updatedAt: Instant
    
    // Default implementation using abstract properties
    fun isModified(): Boolean = createdAt != updatedAt
    fun age(): Duration = Duration.between(createdAt, Instant.now())
}
 
// Kotlin class implementing multiple interfaces
class Article(
    override val id: String,
    override val createdAt: Instant,
    override var updatedAt: Instant,
    val title: String
) : Identifiable, Timestamped {
    // Gets getFormattedId(), isModified(), age() for free
}