Inheritance

How Java inheritance works — extends, super, method overriding, and when to use inheritance vs composition in real enterprise projects.

// Abstract base class — defines the contract
public abstract class Payment {
    protected final String paymentId;
    protected final BigDecimal amount;
    protected final String currency;
    protected PaymentStatus status;
    
    protected Payment(String paymentId, BigDecimal amount, String currency) {
        this.paymentId = paymentId;
        this.amount = amount;
        this.currency = currency;
        this.status = PaymentStatus.PENDING;
    }
    
    // Template method pattern — defines the algorithm structure
    public final PaymentResult process() {
        validate();                    // common validation
        PaymentResult result = execute(); // subclass-specific execution
        postProcess(result);           // common post-processing
        return result;
    }
    
    // Common validation for all payment types
    protected void validate() {
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Payment amount must be positive");
        }
    }
    
    // Each subclass implements its own execution
    protected abstract PaymentResult execute();
    
    // Hook method — subclasses can override if needed
    protected void postProcess(PaymentResult result) {
        this.status = result.isSuccess() ? PaymentStatus.COMPLETED : PaymentStatus.FAILED;
    }
    
    public String getPaymentId() { return paymentId; }
    public BigDecimal getAmount() { return amount; }
    public PaymentStatus getStatus() { return status; }
}

// Concrete subclass
public class CreditCardPayment extends Payment {
    private final String cardToken;
    private final String cvv;
    
    public CreditCardPayment(String paymentId, BigDecimal amount,
                              String currency, String cardToken, String cvv) {
        super(paymentId, amount, currency);
        this.cardToken = cardToken;
        this.cvv = cvv;
    }
    
    @Override
    protected void validate() {
        super.validate();  // call parent validation first
        if (cardToken == null || cardToken.isBlank()) {
            throw new IllegalArgumentException("Card token required");
        }
    }
    
    @Override
    protected PaymentResult execute() {
        // Call payment gateway API
        return paymentGateway.charge(cardToken, amount, currency);
    }
}

// Another subclass
public class BankTransferPayment extends Payment {
    private final String iban;
    
    public BankTransferPayment(String paymentId, BigDecimal amount,
                                String currency, String iban) {
        super(paymentId, amount, currency);
        this.iban = iban;
    }
    
    @Override
    protected PaymentResult execute() {
        return bankService.transfer(iban, amount, currency);
    }
}

In modern Spring Boot applications, inheritance is used sparingly: @MappedSuperclass for audit fields, abstract base controllers for shared error handling, and occasionally for strategy patterns. The dominant pattern is composition via dependency injection — services depend on interfaces, not concrete classes. This is more testable, more flexible, and avoids inheritance pitfalls.