Bloaters — Practice Tasks¶

class InvoiceProcessor {
    public BigDecimal processInvoice(Invoice invoice, Customer customer, String couponCode) {
        // validate
        if (invoice == null) throw new IllegalArgumentException("invoice is null");
        if (invoice.getLines().isEmpty()) throw new IllegalStateException("invoice has no lines");
        if (customer == null) throw new IllegalArgumentException("customer is null");

        // subtotal
        BigDecimal subtotal = BigDecimal.ZERO;
        for (InvoiceLine line : invoice.getLines()) {
            BigDecimal lineTotal = line.getUnitPrice().multiply(BigDecimal.valueOf(line.getQuantity()));
            if (line.getCategory() == Category.BOOK) {
                lineTotal = lineTotal.multiply(new BigDecimal("0.95"));
            }
            subtotal = subtotal.add(lineTotal);
        }

        // discount
        BigDecimal discount = BigDecimal.ZERO;
        if ("SAVE10".equals(couponCode)) {
            discount = subtotal.multiply(new BigDecimal("0.10"));
        }
        if (customer.getTier() == Tier.GOLD) {
            discount = discount.add(subtotal.multiply(new BigDecimal("0.05")));
        }

        // tax
        BigDecimal taxable = subtotal.subtract(discount);
        BigDecimal taxRate = customer.getState().equals("CA")
            ? new BigDecimal("0.0875")
            : new BigDecimal("0.07");
        BigDecimal tax = taxable.multiply(taxRate);

        return subtotal.subtract(discount).add(tax);
    }
}

class InvoiceProcessor {
    public BigDecimal processInvoice(Invoice invoice, Customer customer, String couponCode) {
        validate(invoice, customer);
        BigDecimal subtotal = computeSubtotal(invoice);
        BigDecimal discount = computeDiscount(subtotal, customer, couponCode);
        BigDecimal tax = computeTax(subtotal.subtract(discount), customer);
        return subtotal.subtract(discount).add(tax);
    }

    private void validate(Invoice invoice, Customer customer) {
        if (invoice == null) throw new IllegalArgumentException("invoice is null");
        if (invoice.getLines().isEmpty()) throw new IllegalStateException("invoice has no lines");
        if (customer == null) throw new IllegalArgumentException("customer is null");
    }

    private BigDecimal computeSubtotal(Invoice invoice) {
        return invoice.getLines().stream()
            .map(this::lineTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    private BigDecimal lineTotal(InvoiceLine line) {
        BigDecimal total = line.getUnitPrice().multiply(BigDecimal.valueOf(line.getQuantity()));
        return line.getCategory() == Category.BOOK
            ? total.multiply(new BigDecimal("0.95"))
            : total;
    }

    private BigDecimal computeDiscount(BigDecimal subtotal, Customer customer, String couponCode) {
        BigDecimal coupon = "SAVE10".equals(couponCode)
            ? subtotal.multiply(new BigDecimal("0.10"))
            : BigDecimal.ZERO;
        BigDecimal loyalty = customer.getTier() == Tier.GOLD
            ? subtotal.multiply(new BigDecimal("0.05"))
            : BigDecimal.ZERO;
        return coupon.add(loyalty);
    }

    private BigDecimal computeTax(BigDecimal taxable, Customer customer) {
        BigDecimal rate = "CA".equals(customer.getState())
            ? new BigDecimal("0.0875")
            : new BigDecimal("0.07");
        return taxable.multiply(rate);
    }
}

final class AccountId {
    private final String value;
    public AccountId(String value) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException("AccountId cannot be blank");
        }
        this.value = value;
    }
    public String value() { return value; }
}

enum Currency { USD, EUR, GBP, JPY }

final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        if (amount == null || currency == null) {
            throw new IllegalArgumentException();
        }
        if (amount.signum() < 0) {
            throw new IllegalArgumentException("Money cannot be negative");
        }
        this.amount = amount;
        this.currency = currency;
    }

    public Money add(Money other) {
        if (this.currency != other.currency) {
            throw new IllegalStateException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount), currency);
    }
    public BigDecimal amount() { return amount; }
    public Currency currency() { return currency; }
}

class TransferService {
    public void transfer(AccountId from, AccountId to, Money amount) { /* ... */ }
}

// Now: `transfer(amountObject, fromId, toId)` is a compile error.
// `transfer(fromId, toId, amountObject)` works.

class GameCharacter {
    // identity
    private String name;
    private int level;
    private long experiencePoints;

    // stats
    private int strength, dexterity, constitution, intelligence, wisdom, charisma;

    // health
    private int currentHp, maxHp, currentMp, maxMp;

    // inventory
    private List<Item> backpack;
    private int gold;

    // equipment
    private Item helmet, chest, legs, boots, mainHand, offHand;

    // combat
    private boolean inCombat;
    private List<StatusEffect> activeEffects;
    private long lastAttackTime;

    // 60+ methods...
}

record Identity(String name, int level, long experiencePoints) {}

record Stats(int strength, int dexterity, int constitution,
             int intelligence, int wisdom, int charisma) {}

class HealthBar {
    private int currentHp, maxHp, currentMp, maxMp;
    public void takeDamage(int dmg) { currentHp = Math.max(0, currentHp - dmg); }
    public void heal(int amount) { currentHp = Math.min(maxHp, currentHp + amount); }
    public boolean isDead() { return currentHp == 0; }
    // ...
}

class Inventory {
    private final List<Item> backpack = new ArrayList<>();
    private int gold;
    public void addItem(Item item) { backpack.add(item); }
    public boolean spend(int amount) {
        if (gold < amount) return false;
        gold -= amount;
        return true;
    }
}

class Equipment {
    private Item helmet, chest, legs, boots, mainHand, offHand;
    public void equip(EquipSlot slot, Item item) { /* ... */ }
}

class CombatState {
    private boolean inCombat;
    private List<StatusEffect> activeEffects = new ArrayList<>();
    private long lastAttackTime;
    public boolean canAttack(long now, long cooldownMs) { return now - lastAttackTime > cooldownMs; }
}

class GameCharacter {
    private final Identity identity;
    private Stats stats;
    private final HealthBar health;
    private final Inventory inventory;
    private final Equipment equipment;
    private final CombatState combat;
}

class FlightSearch {
    public List<Flight> search(
        String fromAirportCode, String fromCity, String fromCountry,
        String toAirportCode, String toCity, String toCountry,
        LocalDate departureDate, LocalDate returnDate,
        int adultCount, int childCount, int infantCount,
        String cabinClass
    ) { ... }
}

record Airport(String code, String city, String country) {
    public Airport {
        if (code == null || code.length() != 3) {
            throw new IllegalArgumentException("Airport code must be 3 letters");
        }
    }
}

record DateRange(LocalDate from, LocalDate to) {
    public DateRange {
        if (to.isBefore(from)) throw new IllegalArgumentException("Return before departure");
    }
}

record PassengerCount(int adults, int children, int infants) {
    public PassengerCount {
        if (adults < 1) throw new IllegalArgumentException("At least one adult required");
        if (infants > adults) throw new IllegalArgumentException("Each infant needs an adult");
    }
}

enum CabinClass { ECONOMY, PREMIUM_ECONOMY, BUSINESS, FIRST }

record FlightSearchRequest(
    Airport origin,
    Airport destination,
    DateRange travelDates,
    PassengerCount passengers,
    CabinClass cabin
) {}

class FlightSearch {
    public List<Flight> search(FlightSearchRequest request) { ... }
}

class StatisticsAnalyzer {
    public Stats analyze(double[] data) {
        int n = data.length;
        double sum = 0, sumSq = 0, min = Double.POSITIVE_INFINITY, max = Double.NEGATIVE_INFINITY;
        int positiveCount = 0, negativeCount = 0;
        for (double x : data) {
            sum += x;
            sumSq += x * x;
            if (x < min) min = x;
            if (x > max) max = x;
            if (x > 0) positiveCount++;
            if (x < 0) negativeCount++;
        }
        double mean = sum / n;
        double variance = (sumSq / n) - mean * mean;
        double stdDev = Math.sqrt(variance);
        double median = computeMedian(data);
        // ... 50 more lines computing percentiles, mode, kurtosis ...
        return new Stats(n, mean, stdDev, min, max, positiveCount, negativeCount, median /* + more */);
    }
}

class StatisticsAnalyzer {
    public Stats analyze(double[] data) {
        return new Analysis(data).compute();
    }
}

class Analysis {
    private final double[] data;
    private final int n;
    private double sum, sumSq, min, max;
    private int positiveCount, negativeCount;

    Analysis(double[] data) {
        this.data = data;
        this.n = data.length;
        this.min = Double.POSITIVE_INFINITY;
        this.max = Double.NEGATIVE_INFINITY;
    }

    public Stats compute() {
        accumulate();
        double mean = sum / n;
        double stdDev = Math.sqrt(sumSq / n - mean * mean);
        double median = computeMedian();
        // ... percentiles, mode, kurtosis as separate methods ...
        return new Stats(n, mean, stdDev, min, max, positiveCount, negativeCount, median);
    }

    private void accumulate() {
        for (double x : data) {
            sum += x;
            sumSq += x * x;
            if (x < min) min = x;
            if (x > max) max = x;
            if (x > 0) positiveCount++;
            if (x < 0) negativeCount++;
        }
    }

    private double computeMedian() { ... }
    // ... other computations as methods, all sharing the analysis state
}