Java OOP and Design: Classes, Interfaces, Abstraction, and Composition

public class Order {
    // Fields — the state
    private final String orderId;
    private final String customerId;
    private final List<LineItem> items;
    private OrderStatus status;
 
    // Constructor — builds instances
    public Order(String orderId, String customerId, List<LineItem> items) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.items = List.copyOf(items);  // defensive copy
        this.status = OrderStatus.PENDING;
    }
 
    // Behavior — methods that operate on state
    public void confirm() {
        if (status != OrderStatus.PENDING) {
            throw new IllegalStateException("Only pending orders can be confirmed");
        }
        this.status = OrderStatus.CONFIRMED;
    }
 
    public boolean isShippable() {
        return status == OrderStatus.CONFIRMED && !items.isEmpty();
    }
}

// Declaration and instantiation
Order order;               // declares a reference (null initially)
order = new Order(...);    // allocates object on heap, assigns reference
 
// What happens in memory:
// 1. Class loading: Order class metadata loaded into Metaspace
// 2. Heap allocation: ~24+ bytes for the object (header + fields)
// 3. Constructor runs: initializes fields
// 4. Reference stored on stack or as field in owning object

Order a = new Order("1", "cust1", items);
Order b = new Order("1", "cust1", items);
Order c = a;
 
a == c;         // true — same reference
a == b;         // false — different objects
a.equals(b);    // true — logical equality (if properly overridden)

public class Customer {
    private final String id;
    private final String email;
    private final String name;
 
    // Primary constructor
    public Customer(String id, String email, String name) {
        this.id = Objects.requireNonNull(id, "id must not be null");
        this.email = validateEmail(email);
        this.name = Objects.requireNonNull(name, "name must not be null");
    }
 
    // Overloaded constructor delegates to primary
    public Customer(String email, String name) {
        this(UUID.randomUUID().toString(), email, name);
    }
 
    private static String validateEmail(String email) {
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + email);
        }
        return email;
    }
}

public class BankAccount {
    // Private state — no direct access from outside
    private Money balance;
    private final List<Transaction> ledger = new ArrayList<>();
 
    // Public behavior — controlled access to state
    public void deposit(Money amount) {
        if (amount.isNegative()) {
            throw new IllegalArgumentException("Cannot deposit negative amount");
        }
        balance = balance.add(amount);
        ledger.add(new Transaction(TransactionType.DEPOSIT, amount));
    }
 
    public Money getBalance() {
        return balance;  // Money is immutable, safe to expose
    }
 
    public List<Transaction> getLedger() {
        return Collections.unmodifiableList(ledger);  // defensive view
    }
}

public class Payment {
    protected final String transactionId;
    protected final Money amount;
 
    public Payment(String transactionId, Money amount) {
        this.transactionId = transactionId;
        this.amount = amount;
    }
 
    public void process() {
        // Common payment processing logic
        validate();
        charge();
        notify();
    }
 
    protected void validate() { /* base validation */ }
    protected abstract void charge();
    protected void notify() { /* send receipt */ }
}
 
public class CreditCardPayment extends Payment {
    private final String cardNumber;
 
    public CreditCardPayment(String transactionId, Money amount, String cardNumber) {
        super(transactionId, amount);
        this.cardNumber = cardNumber;
    }
 
    @Override
    protected void charge() {
        // Credit card specific charging logic
    }
}

// Compile-time polymorphism (method overloading)
public class Calculator {
    public int add(int a, int b) { return a + b; }
    public double add(double a, double b) { return a + b; }
    // Which method to call is decided at compile time
}
 
// Runtime polymorphism (method overriding)
PaymentProcessor processor = new CreditCardProcessor();
processor.process(amount);
// Which process() runs is decided at runtime based on actual object type

// Interface — the polymorphic contract
public interface NotificationChannel {
    void send(String recipient, String message);
}
 
// Multiple implementations
public class EmailChannel implements NotificationChannel {
    public void send(String recipient, String message) {
        // Send via SMTP
    }
}
 
public class SMSChannel implements NotificationChannel {
    public void send(String recipient, String message) {
        // Send via SMS gateway
    }
}
 
// Client — depends on abstraction, not concrete type
public class NotificationService {
    private final NotificationChannel channel;
 
    public NotificationService(NotificationChannel channel) {
        this.channel = channel;  // any implementation works
    }
 
    public void notifyUser(String email, String message) {
        channel.send(email, message);
    }
}

// Define the contract
public interface PaymentGateway {
    PaymentResult charge(PaymentRequest request);
    PaymentResult refund(String transactionId, Money amount);
    boolean isAvailable();
}
 
// Implement the contract
public class StripeGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(PaymentRequest request) {
        // Stripe-specific HTTP call
    }
 
    @Override
    public PaymentResult refund(String transactionId, Money amount) {
        // Stripe refund logic
    }
 
    @Override
    public boolean isAvailable() {
        return healthCheck();
    }
}
 
// Consumer depends only on the interface
public class CheckoutService {
    private final PaymentGateway paymentGateway;
 
    public CheckoutService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
 
    public Receipt checkout(Cart cart) {
        PaymentRequest request = buildPaymentRequest(cart);
        PaymentResult result = paymentGateway.charge(request);
        return buildReceipt(result);
    }
}

public interface PaymentGateway {
    // Abstract method — must be implemented
    PaymentResult charge(PaymentRequest request);
 
    // Default method — optional override with fallback
    default PaymentResult refund(String transactionId, Money amount) {
        throw new UnsupportedOperationException("Refunds not supported");
    }
 
    // Static method — utility on the interface itself
    static PaymentGateway defaultGateway() {
        return new StripeGateway();
    }
 
    // Private method (Java 9+) — shared helper for default methods
    private void log(String message) {
        Logger.log("[PaymentGateway] " + message);
    }
}

public abstract class AbstractPaymentProcessor {
    // Fields — concrete state shared by subclasses
    protected final String merchantId;
    protected final HttpClient httpClient;
    private final MetricsRegistry metrics;
 
    // Constructor — initialization logic
    protected AbstractPaymentProcessor(String merchantId, HttpClient httpClient,
                                        MetricsRegistry metrics) {
        this.merchantId = merchantId;
        this.httpClient = httpClient;
        this.metrics = metrics;
    }
 
    // Concrete method — shared behavior
    public PaymentResult process(PaymentRequest request) {
        long start = System.nanoTime();
        try {
            PaymentResult result = doCharge(request);
            metrics.recordSuccess(System.nanoTime() - start);
            return result;
        } catch (Exception e) {
            metrics.recordFailure(System.nanoTime() - start);
            throw new PaymentException("Payment failed", e);
        }
    }
 
    // Template method pattern — subclasses provide steps
    public final PaymentResult fullFlow(PaymentRequest request) {
        validate(request);           // step 1 (may be overridden)
        PaymentResult result = doCharge(request);  // step 2 (abstract)
        postProcess(result);         // step 3 (may be overridden)
        return result;
    }
 
    // Abstract method — must be implemented
    protected abstract PaymentResult doCharge(PaymentRequest request);
 
    // Hook methods — optional override
    protected void validate(PaymentRequest request) { /* default validation */ }
    protected void postProcess(PaymentResult result) { /* default post-processing */ }
}

// BAD: Inheritance creates rigid coupling
public class OrderService extends BaseService {
    // Inherits all of BaseService — can't remove unwanted methods
    // Changing BaseService may break OrderService
    // Can't easily swap database access strategy
}
 
// GOOD: Composition with dependency injection
public class OrderService {
    private final OrderRepository orderRepo;
    private final PaymentGateway paymentGateway;
    private final NotificationService notifier;
    private final OrderValidator validator;
 
    public OrderService(OrderRepository orderRepo,
                        PaymentGateway paymentGateway,
                        NotificationService notifier,
                        OrderValidator validator) {
        this.orderRepo = orderRepo;
        this.paymentGateway = paymentGateway;
        this.notifier = notifier;
        this.validator = validator;
    }
 
    public Receipt placeOrder(OrderRequest request) {
        validator.validate(request);
        Order order = orderRepo.save(request.toOrder());
        PaymentResult payment = paymentGateway.charge(order.getPayment());
        notifier.sendConfirmation(order.getCustomerEmail(), order);
        return new Receipt(order, payment);
    }
}

// Instead of subclassing for every pricing variation:
public class PricingService {
    private final PricingStrategy strategy;
 
    public PricingService(PricingStrategy strategy) {
        this.strategy = strategy;
    }
 
    public Money calculatePrice(Order order) {
        return strategy.compute(order);
    }
}
 
// Strategies are composed — not inherited
@FunctionalInterface
public interface PricingStrategy {
    Money compute(Order order);
}
 
// Each strategy is a separate, testable, swappable component
PricingStrategy volumeDiscount = order ->
    order.getTotal().applyDiscount(order.getQuantity() > 100 ? 0.15 : 0);
 
PricingStrategy seasonalPricing = order -> {
    if (isPeakSeason()) return order.getTotal().multiply(1.2);
    return order.getTotal();
};

// File storage abstraction
public interface FileStore {
    void save(String path, byte[] data);
    byte[] read(String path);
}
 
// Local file system
public class LocalFileStore implements FileStore { /* ... */ }
 
// S3-compatible storage
public class S3FileStore implements FileStore { /* ... */ }
 
// Usage — swap storage layer without changing business logic
public class DocumentService {
    private final FileStore fileStore;
    public DocumentService(FileStore fileStore) { this.fileStore = fileStore; }
}

public abstract class DataExportJob {
    public final void execute() {
        List<Data> data = fetchData();        // abstract
        String formatted = format(data);       // abstract
        writeOutput(formatted);                // abstract
        cleanup();                             // hook (optional)
    }
 
    protected abstract List<Data> fetchData();
    protected abstract String format(List<Data> data);
    protected abstract void writeOutput(String content);
    protected void cleanup() { /* default: no-op */ }
}

public class PaymentGatewayFactory {
    private final Map<PaymentMethod, PaymentGateway> gateways;
 
    public PaymentGatewayFactory(List<PaymentGateway> gatewayList) {
        this.gateways = gatewayList.stream()
            .collect(Collectors.toMap(PaymentGateway::supportedMethod, Function.identity()));
    }
 
    public PaymentGateway forMethod(PaymentMethod method) {
        PaymentGateway gateway = gateways.get(method);
        if (gateway == null) throw new IllegalArgumentException("Unsupported: " + method);
        return gateway;
    }
}