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
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

// ═══════════════════════════════════════════════════
// SCENARIO: Report generation with shared formatting logic
// ═══════════════════════════════════════════════════
 
// Interface defines the contract
public interface ReportGenerator {
    Report generate(ReportRequest request);
    List<String> getSupportedFormats();
}
 
 
// Abstract class provides MASSIVE shared implementation
public abstract class AbstractReportGenerator implements ReportGenerator {
    
    protected final DataSource dataSource;
    protected final Logger logger;
    protected final ReportCache cache;
    
    protected AbstractReportGenerator(DataSource dataSource, ReportCache cache) {
        this.dataSource = dataSource;
        this.cache = cache;
        this.logger = LoggerFactory.getLogger(getClass());
    }
    
    // ───────────────────────────────────────────────────
    // SHARED IMPLEMENTATION: 80% of the work is here
    // ───────────────────────────────────────────────────
    
    @Override
    public final Report generate(ReportRequest request) {
        logger.info("Starting report generation: {}", request.getReportType());
        long startTime = System.currentTimeMillis();
        
        try {
            // Check cache first
            String cacheKey = buildCacheKey(request);
            Report cached = cache.get(cacheKey);
            if (cached != null && !request.isForceRefresh()) {
                logger.debug("Returning cached report");
                return cached;
            }
            
            // Validate request (shared validation)
            validateRequest(request);
            
            // Fetch data (shared data access pattern)
            ReportData data = fetchReportData(request);
            
            // Transform data (shared transformations)
            ReportData transformedData = applyTransformations(data, request);
            
            // Format output (SUBCLASS SPECIFIC)
            Report report = formatReport(transformedData, request);
            
            // Post-processing (shared)
            report = addMetadata(report, request);
            report = addBranding(report);
            
            // Cache result
            cache.put(cacheKey, report, getCacheDuration());
            
            long duration = System.currentTimeMillis() - startTime;
            logger.info("Report generated in {}ms", duration);
            
            return report;
            
        } catch (Exception e) {
            logger.error("Report generation failed", e);
            throw new ReportGenerationException("Failed to generate report", e);
        }
    }
    
    // Shared: Request validation logic
    private void validateRequest(ReportRequest request) {
        if (request.getStartDate().isAfter(request.getEndDate())) {
            throw new InvalidRequestException("Start date must be before end date");
        }
        if (request.getFilters().size() > 10) {
            throw new InvalidRequestException("Maximum 10 filters allowed");
        }
        // More validation...
    }
    
    // Shared: Data fetching with connection handling
    private ReportData fetchReportData(ReportRequest request) {
        try (Connection conn = dataSource.getConnection()) {
            String query = buildDataQuery(request); // Abstract hook
            try (PreparedStatement stmt = conn.prepareStatement(query)) {
                applyQueryParameters(stmt, request);
                ResultSet rs = stmt.executeQuery();
                return mapResultSet(rs);
            }
        } catch (SQLException e) {
            throw new DataAccessException("Failed to fetch report data", e);
        }
    }
    
    // Shared: Data transformation pipeline
    private ReportData applyTransformations(ReportData data, ReportRequest request) {
        ReportData result = data;
        
        // Apply filters
        for (Filter filter : request.getFilters()) {
            result = result.applyFilter(filter);
        }
        
        // Apply aggregations
        if (request.hasAggregations()) {
            result = result.aggregate(request.getAggregations());
        }
        
        // Apply sorting
        if (request.getSortBy() != null) {
            result = result.sortBy(request.getSortBy(), request.getSortOrder());
        }
        
        return result;
    }
    
    // Shared: Add metadata to all reports
    private Report addMetadata(Report report, ReportRequest request) {
        return report.withMetadata(
            Map.of(
                "generatedAt", Instant.now().toString(),
                "requestedBy", request.getRequesterId(),
                "reportType", request.getReportType(),
                "parameters", request.getParameterSummary()
            )
        );
    }
    
    // Shared: Add company branding
    private Report addBranding(Report report) {
        return report
            .withHeader(getCompanyHeader())
            .withFooter(getCompanyFooter());
    }
    
    // ───────────────────────────────────────────────────
    // ABSTRACT METHODS: Subclasses implement only these
    // ───────────────────────────────────────────────────
    
    // Each report type queries data differently
    protected abstract String buildDataQuery(ReportRequest request);
    
    // Each output format has different formatting logic
    protected abstract Report formatReport(ReportData data, ReportRequest request);
    
    // Different report types have different cache needs
    protected abstract Duration getCacheDuration();
    
    // ───────────────────────────────────────────────────
    // PROTECTED HELPERS: Available to subclasses
    // ───────────────────────────────────────────────────
    
    protected String formatCurrency(BigDecimal amount, String currency) {
        return NumberFormat.getCurrencyInstance(Locale.forLanguageTag(currency))
            .format(amount);
    }
    
    protected String formatDate(LocalDate date) {
        return date.format(DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    protected String formatPercentage(double value) {
        return String.format("%.2f%%", value * 100);
    }
}

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

// PDF Report Generator - only implements what's unique
public class PdfReportGenerator extends AbstractReportGenerator {
    
    private final PdfRenderer pdfRenderer;
    
    public PdfReportGenerator(DataSource ds, ReportCache cache, PdfRenderer renderer) {
        super(ds, cache);
        this.pdfRenderer = renderer;
    }
    
    @Override
    protected String buildDataQuery(ReportRequest request) {
        // PDF reports need all columns for rich formatting
        return "SELECT * FROM " + request.getTableName() + 
               " WHERE created_at BETWEEN ? AND ?";
    }
    
    @Override
    protected Report formatReport(ReportData data, ReportRequest request) {
        // PDF-specific formatting
        PdfDocument doc = pdfRenderer.newDocument();
        
        doc.addTitle(request.getReportTitle());
        doc.addTable(data.toTableModel());
        doc.addChart(data.toChartData());
        
        return new PdfReport(doc.render());
    }
    
    @Override
    protected Duration getCacheDuration() {
        return Duration.ofHours(24); // PDFs are expensive - cache longer
    }
    
    @Override
    public List<String> getSupportedFormats() {
        return List.of("pdf", "pdf/a");
    }
}
 
 
// CSV Report Generator - also minimal
public class CsvReportGenerator extends AbstractReportGenerator {
    
    public CsvReportGenerator(DataSource ds, ReportCache cache) {
        super(ds, cache);
    }
    
    @Override
    protected String buildDataQuery(ReportRequest request) {
        // CSV only needs requested columns
        String columns = String.join(", ", request.getRequestedColumns());
        return "SELECT " + columns + " FROM " + request.getTableName() +
               " WHERE created_at BETWEEN ? AND ?";
    }
    
    @Override
    protected Report formatReport(ReportData data, ReportRequest request) {
        // CSV-specific formatting
        StringBuilder csv = new StringBuilder();
        
        // Header row
        csv.append(String.join(",", data.getColumnNames())).append("
");
        
        // Data rows
        for (Object[] row : data.getRows()) {
            csv.append(Arrays.stream(row)
                .map(this::escapeCsv)
                .collect(Collectors.joining(","))
            ).append("
");
        }
        
        return new CsvReport(csv.toString());
    }
    
    @Override
    protected Duration getCacheDuration() {
        return Duration.ofMinutes(30); // CSVs are cheap - shorter cache
    }
    
    @Override
    public List<String> getSupportedFormats() {
        return List.of("csv", "csv-utf8");
    }
    
    private String escapeCsv(Object value) {
        String str = value == null ? "" : value.toString();
        if (str.contains(",") || str.contains("\"")) {
            return "\"" + str.replace("\"", "\"\"") + "\"";
        }
        return str;
    }
}

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

// ═══════════════════════════════════════════════════
// SCENARIO: HTTP client with shared connection state
// ═══════════════════════════════════════════════════
 
public abstract class ManagedHttpClient {
    
    // ───────────────────────────────────────────────────
    // COMMON STATE: All HTTP clients need these
    // ───────────────────────────────────────────────────
    
    // Private: Internal infrastructure subclasses shouldn't touch
    private final ConnectionPool connectionPool;
    private final CircuitBreaker circuitBreaker;
    private final AtomicLong requestCount;
    private final AtomicLong errorCount;
    
    // Protected: Subclasses can access configuration
    protected final HttpClientConfig config;
    protected final Logger logger;
    protected final MetricsRegistry metrics;
    
    // ───────────────────────────────────────────────────
    // CONSTRUCTOR: Initialize all common state
    // ───────────────────────────────────────────────────
    
    protected ManagedHttpClient(HttpClientConfig config, MetricsRegistry metrics) {
        this.config = config;
        this.metrics = metrics;
        this.logger = LoggerFactory.getLogger(getClass());
        this.requestCount = new AtomicLong(0);
        this.errorCount = new AtomicLong(0);
        
        // Initialize connection pool based on config
        this.connectionPool = new ConnectionPool(
            config.getMaxConnections(),
            config.getConnectionTimeout(),
            config.getIdleTimeout()
        );
        
        // Initialize circuit breaker
        this.circuitBreaker = new CircuitBreaker(
            config.getCircuitBreakerThreshold(),
            config.getCircuitBreakerTimeout()
        );
        
        logger.info(
            "Initialized {} with {} max connections",
            getClass().getSimpleName(),
            config.getMaxConnections()
        );
    }
    
    // ───────────────────────────────────────────────────
    // METHODS USING COMMON STATE
    // ───────────────────────────────────────────────────
    
    public final Response execute(Request request) {
        // Use common state: check circuit breaker
        if (!circuitBreaker.allowRequest()) {
            metrics.increment("http.circuit_open");
            throw new CircuitOpenException("Circuit breaker is open");
        }
        
        // Use common state: get pooled connection
        Connection connection = connectionPool.acquire(config.getConnectionTimeout());
        requestCount.incrementAndGet();
        
        try {
            long startTime = System.currentTimeMillis();
            
            // Subclass-specific execution
            Response response = executeWithConnection(request, connection);
            
            // Update common state based on result
            long duration = System.currentTimeMillis() - startTime;
            if (response.isSuccessful()) {
                circuitBreaker.recordSuccess();
                metrics.recordLatency("http.success", duration);
            } else {
                handleError(response);
            }
            
            return response;
            
        } catch (Exception e) {
            handleException(e);
            throw e;
        } finally {
            connectionPool.release(connection);
        }
    }
    
    // Use common state: track and record errors
    private void handleError(Response response) {
        errorCount.incrementAndGet();
        circuitBreaker.recordFailure();
        metrics.increment("http.error." + response.getStatusCode());
    }
    
    private void handleException(Exception e) {
        errorCount.incrementAndGet();
        circuitBreaker.recordFailure();
        metrics.increment("http.exception");
        logger.error("Request failed", e);
    }
    
    // Expose statistics using common state
    public ClientStatistics getStatistics() {
        return new ClientStatistics(
            requestCount.get(),
            errorCount.get(),
            connectionPool.getActiveConnections(),
            connectionPool.getIdleConnections(),
            circuitBreaker.getState()
        );
    }
    
    // Lifecycle management using common state
    public void shutdown() {
        logger.info("Shutting down HTTP client");
        connectionPool.close();
    }
    
    // ───────────────────────────────────────────────────
    // ABSTRACT: Subclasses implement protocol specifics
    // ───────────────────────────────────────────────────
    
    protected abstract Response executeWithConnection(Request req, Connection conn);
}
 
 
// ═══════════════════════════════════════════════════
// CONCRETE IMPLEMENTATIONS: Inherit all the state
// ═══════════════════════════════════════════════════
 
public class RestClient extends ManagedHttpClient {
    
    private final ObjectMapper jsonMapper;
    
    public RestClient(HttpClientConfig config, MetricsRegistry metrics) {
        super(config, metrics); // Initialize all common state
        this.jsonMapper = new ObjectMapper();
    }
    
    @Override
    protected Response executeWithConnection(Request request, Connection conn) {
        // REST-specific: JSON handling
        if (request.hasBody()) {
            request.setHeader("Content-Type", "application/json");
            request.setBody(jsonMapper.writeValueAsBytes(request.getPayload()));
        }
        
        // Use inherited state: logger, config
        logger.debug("Executing REST request to {}", request.getUrl());
        
        RawResponse raw = conn.send(request);
        
        return new Response(
            raw.getStatusCode(),
            jsonMapper.readValue(raw.getBody(), Map.class)
        );
    }
}
 
 
public class SoapClient extends ManagedHttpClient {
    
    private final XmlSerializer xmlSerializer;
    
    public SoapClient(HttpClientConfig config, MetricsRegistry metrics) {
        super(config, metrics);
        this.xmlSerializer = new XmlSerializer();
    }
    
    @Override
    protected Response executeWithConnection(Request request, Connection conn) {
        // SOAP-specific: XML handling
        String soapEnvelope = xmlSerializer.wrapInEnvelope(request.getPayload());
        request.setHeader("Content-Type", "text/xml");
        request.setHeader("SOAPAction", request.getAction());
        request.setBody(soapEnvelope.getBytes());
        
        // Use inherited state
        logger.debug("Executing SOAP request: {}", request.getAction());
        
        RawResponse raw = conn.send(request);
        
        Object result = xmlSerializer.parseEnvelope(raw.getBody());
        return new Response(raw.getStatusCode(), result);
    }
}

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

// ═══════════════════════════════════════════════════
// SCENARIO: Data import with fixed validation/processing flow
// ═══════════════════════════════════════════════════
 
public abstract class DataImporter<T> {
    
    protected final Logger logger;
    protected final ImportStatistics stats;
    
    protected DataImporter() {
        this.logger = LoggerFactory.getLogger(getClass());
        this.stats = new ImportStatistics();
    }
    
    // ───────────────────────────────────────────────────
    // TEMPLATE METHOD: The invariant algorithm skeleton
    // 'final' ensures subclasses cannot change the flow
    // ───────────────────────────────────────────────────
    
    public final ImportResult importData(InputStream source) {
        logger.info("Starting data import");
        stats.reset();
        
        try {
            // Step 1: Initialize (hook - optional customization)
            initialize();
            
            // Step 2: Parse source (abstract - must implement)
            List<T> parsedItems = parseSource(source);
            stats.setTotalRecords(parsedItems.size());
            logger.info("Parsed {} records", parsedItems.size());
            
            // Step 3: Validate each item (uses abstract validation)
            List<T> validItems = new ArrayList<>();
            List<ValidationError> errors = new ArrayList<>();
            
            for (int i = 0; i < parsedItems.size(); i++) {
                T item = parsedItems.get(i);
                
                try {
                    // Core validation (shared)
                    validateNotNull(item);
                    
                    // Type-specific validation (abstract)
                    ValidationResult result = validate(item);
                    
                    if (result.isValid()) {
                        validItems.add(item);
                    } else {
                        errors.add(new ValidationError(i, result.getErrors()));
                        stats.incrementInvalid();
                    }
                } catch (Exception e) {
                    errors.add(new ValidationError(i, e.getMessage()));
                    stats.incrementInvalid();
                }
            }
            
            logger.info("{} valid, {} invalid", validItems.size(), errors.size());
            
            // Step 4: Transform valid items (abstract - must implement)
            List<T> transformedItems = new ArrayList<>();
            for (T item : validItems) {
                T transformed = transform(item);
                transformedItems.add(transformed);
            }
            
            // Step 5: Persist (abstract - must implement)
            int persisted = persist(transformedItems);
            stats.setSuccessfulRecords(persisted);
            
            // Step 6: Cleanup (hook - optional customization)
            cleanup();
            
            // Step 7: Build result (shared)
            return buildResult(stats, errors);
            
        } catch (Exception e) {
            logger.error("Import failed", e);
            return ImportResult.failure(e.getMessage(), stats);
        }
    }
    
    // ───────────────────────────────────────────────────
    // ABSTRACT METHODS: Subclasses MUST customize these
    // ───────────────────────────────────────────────────
    
    // How to parse the input stream into typed objects
    protected abstract List<T> parseSource(InputStream source) throws IOException;
    
    // Type-specific validation rules
    protected abstract ValidationResult validate(T item);
    
    // Optional transformation before persistence
    protected abstract T transform(T item);
    
    // How to persist the items
    protected abstract int persist(List<T> items);
    
    // ───────────────────────────────────────────────────
    // HOOK METHODS: Optional customization points
    // Default implementation does nothing
    // ───────────────────────────────────────────────────
    
    // Called before parsing begins
    protected void initialize() {
        // Default: nothing
        // Override to acquire resources, set up connections, etc.
    }
    
    // Called after persistence completes
    protected void cleanup() {
        // Default: nothing
        // Override to release resources, send notifications, etc.
    }
    
    // ───────────────────────────────────────────────────
    // SHARED METHODS: Common logic, not customizable
    // ───────────────────────────────────────────────────
    
    private void validateNotNull(T item) {
        if (item == null) {
            throw new ValidationException("Item cannot be null");
        }
    }
    
    private ImportResult buildResult(ImportStatistics stats, List<ValidationError> errors) {
        return ImportResult.builder()
            .success(errors.isEmpty())
            .totalRecords(stats.getTotalRecords())
            .successfulRecords(stats.getSuccessfulRecords())
            .failedRecords(stats.getInvalidRecords())
            .errors(errors)
            .duration(stats.getDuration())
            .build();
    }
}

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

// CSV Importer - follows the template, customizes steps
public class CsvUserImporter extends DataImporter<User> {
    
    private final UserRepository repository;
    private Connection dbConnection;
    
    public CsvUserImporter(UserRepository repository) {
        super();
        this.repository = repository;
    }
    
    @Override
    protected void initialize() {
        // Custom setup: acquire database connection
        dbConnection = repository.getConnection();
        logger.debug("Acquired database connection");
    }
    
    @Override
    protected List<User> parseSource(InputStream source) throws IOException {
        // CSV-specific parsing
        List<User> users = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(source))) {
            String line;
            boolean isHeader = true;
            
            while ((line = reader.readLine()) != null) {
                if (isHeader) {
                    isHeader = false;
                    continue;
                }
                
                String[] parts = line.split(",");
                users.add(new User(
                    parts[0].trim(),           // email
                    parts[1].trim(),           // name
                    parts.length > 2 ? parts[2].trim() : null  // phone
                ));
            }
        }
        return users;
    }
    
    @Override
    protected ValidationResult validate(User user) {
        List<String> errors = new ArrayList<>();
        
        if (!user.getEmail().contains("@")) {
            errors.add("Invalid email format");
        }
        if (user.getName() == null || user.getName().length() < 2) {
            errors.add("Name must be at least 2 characters");
        }
        if (repository.existsByEmail(user.getEmail())) {
            errors.add("Email already exists");
        }
        
        return new ValidationResult(errors.isEmpty(), errors);
    }
    
    @Override
    protected User transform(User user) {
        // Normalize data before saving
        return user.toBuilder()
            .email(user.getEmail().toLowerCase().trim())
            .name(normalizeCase(user.getName()))
            .build();
    }
    
    @Override
    protected int persist(List<User> users) {
        return repository.saveAll(users).size();
    }
    
    @Override
    protected void cleanup() {
        // Release database connection
        if (dbConnection != null) {
            repository.releaseConnection(dbConnection);
            logger.debug("Released database connection");
        }
    }
    
    private String normalizeCase(String name) {
        return Arrays.stream(name.split(" "))
            .map(word -> Character.toUpperCase(word.charAt(0)) + 
                         word.substring(1).toLowerCase())
            .collect(Collectors.joining(" "));
    }
}

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

// ═══════════════════════════════════════════════════
// TRUE IS-A: Bank account hierarchy
// ═══════════════════════════════════════════════════
 
// Abstract base - all accounts share these characteristics
public abstract class BankAccount {
    
    // All accounts have these properties
    protected final String accountNumber;
    protected final String accountHolderName;
    protected Money balance;
    protected final List<Transaction> transactionHistory;
    protected final Instant openedAt;
    
    protected BankAccount(String accountNumber, String holderName, Money initialDeposit) {
        this.accountNumber = accountNumber;
        this.accountHolderName = holderName;
        this.balance = initialDeposit;
        this.transactionHistory = new ArrayList<>();
        this.openedAt = Instant.now();
        
        recordTransaction(TransactionType.OPENING_DEPOSIT, initialDeposit);
    }
    
    // All accounts can deposit
    public void deposit(Money amount) {
        if (amount.isNegative()) {
            throw new InvalidOperationException("Cannot deposit negative amount");
        }
        balance = balance.add(amount);
        recordTransaction(TransactionType.DEPOSIT, amount);
    }
    
    // All accounts have a balance
    public Money getBalance() {
        return balance;
    }
    
    // All accounts track transactions
    public List<Transaction> getTransactionHistory() {
        return Collections.unmodifiableList(transactionHistory);
    }
    
    // Statement generation common to all
    public Statement generateStatement(DateRange range) {
        List<Transaction> relevant = transactionHistory.stream()
            .filter(t -> range.contains(t.getTimestamp()))
            .collect(Collectors.toList());
        return new Statement(accountNumber, accountHolderName, relevant);
    }
    
    // Withdrawal rules vary by account type
    public abstract void withdraw(Money amount);
    
    // Interest calculation varies by account type
    public abstract Money calculateInterest();
    
    // Account type specific description
    public abstract String getAccountType();
    
    protected void recordTransaction(TransactionType type, Money amount) {
        transactionHistory.add(new Transaction(type, amount, balance, Instant.now()));
    }
}
 
 
// All specializations are clearly IS-A BankAccount
 
public class SavingsAccount extends BankAccount {
    
    private final BigDecimal interestRate;
    private final int maxWithdrawalsPerMonth;
    private int withdrawalsThisMonth;
    
    public SavingsAccount(String accountNo, String holder, Money initial, 
                          BigDecimal interestRate) {
        super(accountNo, holder, initial);
        this.interestRate = interestRate;
        this.maxWithdrawalsPerMonth = 6;
        this.withdrawalsThisMonth = 0;
    }
    
    @Override
    public void withdraw(Money amount) {
        if (withdrawalsThisMonth >= maxWithdrawalsPerMonth) {
            throw new WithdrawalLimitExceededException(
                "Maximum " + maxWithdrawalsPerMonth + " withdrawals per month"
            );
        }
        if (amount.isGreaterThan(balance)) {
            throw new InsufficientFundsException();
        }
        
        balance = balance.subtract(amount);
        withdrawalsThisMonth++;
        recordTransaction(TransactionType.WITHDRAWAL, amount);
    }
    
    @Override
    public Money calculateInterest() {
        return balance.multiply(interestRate).divide(12); // Monthly interest
    }
    
    @Override
    public String getAccountType() {
        return "Savings Account";
    }
}
 
 
public class CheckingAccount extends BankAccount {
    
    private final Money overdraftLimit;
    
    public CheckingAccount(String accountNo, String holder, Money initial,
                          Money overdraftLimit) {
        super(accountNo, holder, initial);
        this.overdraftLimit = overdraftLimit;
    }
    
    @Override
    public void withdraw(Money amount) {
        Money available = balance.add(overdraftLimit);
        if (amount.isGreaterThan(available)) {
            throw new InsufficientFundsException(
                "Amount exceeds balance plus overdraft limit"
            );
        }
        
        balance = balance.subtract(amount);
        
        // Charge overdraft fee if applicable
        if (balance.isNegative()) {
            Money overdraftFee = Money.of("5.00");
            balance = balance.subtract(overdraftFee);
            recordTransaction(TransactionType.OVERDRAFT_FEE, overdraftFee);
        }
        
        recordTransaction(TransactionType.WITHDRAWAL, amount);
    }
    
    @Override
    public Money calculateInterest() {
        // Checking accounts typically don't earn interest
        return Money.zero();
    }
    
    @Override
    public String getAccountType() {
        return "Checking Account";
    }
}