Refactoring Techniques — The Silent Change Trap

public class OrderProcessor {

    // BEFORE REFACTORING — one giant method doing too many things
    // This is the 'code smell': a method that does more than its name suggests
    public double processOrderBefore(double itemPrice, int quantity, boolean isMember) {
        // Calculate subtotal
        double subtotal = itemPrice * quantity;

        // Apply member discount — this block is a candidate for extraction
        double discountedPrice = subtotal;
        if (isMember) {
            discountedPrice = subtotal * 0.90; // 10% member discount
        }

        // Calculate tax — another candidate for extraction
        double taxAmount = discountedPrice * 0.08; // 8% tax rate
        double total = discountedPrice + taxAmount;

        // Apply free shipping threshold — yet another distinct responsibility
        double shippingCost = 0.0;
        if (total < 50.0) {
            shippingCost = 5.99;
        }

        return total + shippingCost;
    }

    // ─────────────────────────────────────────────
    // AFTER REFACTORING — each concern lives in its own named method
    // The processOrder method now reads like a plain-English summary
    // ─────────────────────────────────────────────

    public double processOrder(double itemPrice, int quantity, boolean isMember) {
        double subtotal = itemPrice * quantity;
        double discountedSubtotal = applyMemberDiscount(subtotal, isMember); // extracted
        double totalWithTax = applyTax(discountedSubtotal);                  // extracted
        double finalTotal = addShippingIfRequired(totalWithTax);             // extracted
        return finalTotal;
    }

    // Each extracted method has ONE job and a name that explains that job
    private double applyMemberDiscount(double subtotal, boolean isMember) {
        if (isMember) {
            return subtotal * 0.90; // members get 10% off
        }
        return subtotal; // non-members pay full price
    }

    private double applyTax(double price) {
        double TAX_RATE = 0.08; // 8% — note: we'll improve this further in the next section
        return price + (price * TAX_RATE);
    }

    private double addShippingIfRequired(double orderTotal) {
        double FREE_SHIPPING_THRESHOLD = 50.0;
        double STANDARD_SHIPPING_COST = 5.99;
        if (orderTotal < FREE_SHIPPING_THRESHOLD) {
            return orderTotal + STANDARD_SHIPPING_COST;
        }
        return orderTotal; // free shipping applies
    }

    public static void main(String[] args) {
        OrderProcessor processor = new OrderProcessor();

        // Non-member buying 3 items at $20 each
        double nonMemberTotal = processor.processOrder(20.0, 3, false);
        System.out.printf("Non-member order total: $%.2f%n", nonMemberTotal);

        // Member buying 3 items at $20 each (gets 10% discount)
        double memberTotal = processor.processOrder(20.0, 3, true);
        System.out.printf("Member order total:     $%.2f%n", memberTotal);

        // Small order that triggers shipping cost
        double smallOrderTotal = processor.processOrder(5.0, 2, false);
        System.out.printf("Small order total:      $%.2f%n", smallOrderTotal);
    }
}

// ─────────────────────────────────────────────
// BEFORE: Magic numbers scattered everywhere
// If the tax rate changes, you have to hunt through the whole codebase
// ─────────────────────────────────────────────
class PricingCalculatorBefore {

    public double getTotalForRegularCustomer(double price) {
        return price + (price * 0.08); // What is 0.08? Why this value?
    }

    public double getTotalForOnlineOrder(double price) {
        return price + (price * 0.08); // Duplicated magic number — danger zone
    }

    public boolean qualifiesForFreeShipping(double orderTotal) {
        return orderTotal >= 50.0; // What is special about 50.0?
    }
}

// ─────────────────────────────────────────────
// AFTER: Named constants in one central location
// Change the tax rate once, it propagates everywhere
// ─────────────────────────────────────────────
public class PricingConfig {

    // Centralised pricing constants — change these and the whole system updates
    public static final double SALES_TAX_RATE             = 0.08;  // 8% state sales tax
    public static final double FREE_SHIPPING_THRESHOLD    = 50.00; // orders over $50 ship free
    public static final double MEMBER_DISCOUNT_RATE       = 0.10;  // 10% loyalty discount
    public static final double STANDARD_SHIPPING_COST     = 5.99;  // flat rate shipping fee
    public static final double PREMIUM_MEMBER_DISCOUNT    = 0.20;  // 20% premium tier discount

    public static void main(String[] args) {
        double orderPrice = 45.00;

        // Now reading the formula is self-explanatory — no comment needed
        double taxAmount = orderPrice * PricingConfig.SALES_TAX_RATE;
        double orderWithTax = orderPrice + taxAmount;

        System.out.printf("Order price:       $%.2f%n", orderPrice);
        System.out.printf("Tax (%.0f%%):        $%.2f%n",
                PricingConfig.SALES_TAX_RATE * 100, taxAmount);
        System.out.printf("Order with tax:    $%.2f%n", orderWithTax);

        // The condition reads like English — no mental translation required
        if (orderWithTax >= PricingConfig.FREE_SHIPPING_THRESHOLD) {
            System.out.println("Shipping:          FREE");
        } else {
            System.out.printf("Shipping:          $%.2f%n",
                    PricingConfig.STANDARD_SHIPPING_COST);
            orderWithTax += PricingConfig.STANDARD_SHIPPING_COST;
        }

        System.out.printf("Final total:       $%.2f%n", orderWithTax);
    }
}

public class LoanApproval {

    // BEFORE: Deeply nested conditionals — the 'arrow anti-pattern'
    // Try to hold all these conditions in your head at once. You can't.
    public String evaluateLoanBefore(int creditScore, double annualIncome,
                                      boolean hasExistingDefault,
                                      int employmentYears) {
        String result;
        if (!hasExistingDefault) {
            if (creditScore >= 700) {
                if (annualIncome >= 40000) {
                    if (employmentYears >= 2) {
                        result = "APPROVED — Standard Rate";
                    } else {
                        result = "DENIED — Insufficient employment history";
                    }
                } else {
                    result = "DENIED — Income below threshold";
                }
            } else {
                result = "DENIED — Credit score too low";
            }
        } else {
            result = "DENIED — Existing default on record";
        }
        return result;
    }

    // ─────────────────────────────────────────────
    // AFTER: Guard clauses + decomposed conditions
    // The failure cases bail out early — the success path is never buried
    // ─────────────────────────────────────────────
    private static final int    MINIMUM_CREDIT_SCORE     = 700;
    private static final double MINIMUM_ANNUAL_INCOME    = 40_000.0;
    private static final int    MINIMUM_EMPLOYMENT_YEARS = 2;

    public String evaluateLoan(int creditScore, double annualIncome,
                                boolean hasExistingDefault,
                                int employmentYears) {

        // Guard clauses: handle disqualifying cases first, return immediately
        // Each rejection reason is isolated and crystal clear
        if (hasExistingDefault) {
            return "DENIED — Existing default on record";
        }
        if (!meetsCreditScoreRequirement(creditScore)) {
            return "DENIED — Credit score below " + MINIMUM_CREDIT_SCORE;
        }
        if (!meetsIncomeRequirement(annualIncome)) {
            return "DENIED — Annual income below $" + (int) MINIMUM_ANNUAL_INCOME;
        }
        if (!meetsEmploymentRequirement(employmentYears)) {
            return "DENIED — Requires " + MINIMUM_EMPLOYMENT_YEARS + "+ years of employment";
        }

        // If we reach here, all criteria are met — the happy path is never buried
        return "APPROVED — Standard Rate";
    }

    // Decomposed conditions: each rule is named and independently testable
    private boolean meetsCreditScoreRequirement(int creditScore) {
        return creditScore >= MINIMUM_CREDIT_SCORE;
    }

    private boolean meetsIncomeRequirement(double annualIncome) {
        return annualIncome >= MINIMUM_ANNUAL_INCOME;
    }

    private boolean meetsEmploymentRequirement(int employmentYears) {
        return employmentYears >= MINIMUM_EMPLOYMENT_YEARS;
    }

    public static void main(String[] args) {
        LoanApproval approver = new LoanApproval();

        // Applicant 1: Everything looks good
        System.out.println("Applicant 1: " +
                approver.evaluateLoan(750, 55000, false, 4));

        // Applicant 2: Has a prior default — rejected immediately by guard clause
        System.out.println("Applicant 2: " +
                approver.evaluateLoan(780, 60000, true, 5));

        // Applicant 3: Good credit, good income, but new to the job
        System.out.println("Applicant 3: " +
                approver.evaluateLoan(720, 48000, false, 1));

        // Applicant 4: Low credit score
        System.out.println("Applicant 4: " +
                approver.evaluateLoan(650, 55000, false, 3));
    }
}

// ─────────────────────────────────────────────
// BEFORE: Feature Envy — Order class has a method
// that is obsessively interested in Customer's data
// ─────────────────────────────────────────────
class Customer {
    private String fullName;
    private String emailAddress;
    private String membershipTier; // "STANDARD", "PREMIUM", "VIP"

    public Customer(String fullName, String emailAddress, String membershipTier) {
        this.fullName = fullName;
        this.emailAddress = emailAddress;
        this.membershipTier = membershipTier;
    }

    public String getFullName()       { return fullName; }
    public String getEmailAddress()   { return emailAddress; }
    public String getMembershipTier() { return membershipTier; }
}

class OrderBefore {
    private double orderTotal;
    private Customer customer;

    public OrderBefore(double orderTotal, Customer customer) {
        this.orderTotal = orderTotal;
        this.customer = customer;
    }

    // SMELL: This method doesn't use 'orderTotal' at all.
    // It only cares about Customer data. It has feature envy.
    // It belongs in Customer, not Order.
    public String generateCustomerSummary() {
        return String.format("Customer: %s | Email: %s | Tier: %s",
                customer.getFullName(),
                customer.getEmailAddress(),
                customer.getMembershipTier());
    }

    public double getOrderTotal() { return orderTotal; }
}

// ─────────────────────────────────────────────
// AFTER: Method moved to the class it belongs in
// Order now only knows about order-related things
// Customer handles its own presentation logic
// ─────────────────────────────────────────────
class CustomerRefactored {
    private String fullName;
    private String emailAddress;
    private String membershipTier;

    public CustomerRefactored(String fullName, String emailAddress, String membershipTier) {
        this.fullName = fullName;
        this.emailAddress = emailAddress;
        this.membershipTier = membershipTier;
    }

    // Method now lives where its data lives — no cross-class reaching
    public String generateSummary() {
        return String.format("Customer: %s | Email: %s | Tier: %s",
                fullName, emailAddress, membershipTier);
    }

    public String getMembershipTier() { return membershipTier; }
}

class OrderRefactored {
    private double orderTotal;
    private CustomerRefactored customer;

    public OrderRefactored(double orderTotal, CustomerRefactored customer) {
        this.orderTotal = orderTotal;
        this.customer = customer;
    }

    // Order only handles order-level logic — clean responsibility
    public String generateOrderSummary() {
        return String.format("%s | Order Total: $%.2f",
                customer.generateSummary(), // asks Customer for its own summary
                orderTotal);
    }
}

public class CustomerReportGenerator {
    public static void main(String[] args) {
        CustomerRefactored customer = new CustomerRefactored(
                "Maria Chen", "maria.chen@example.com", "VIP");

        OrderRefactored order = new OrderRefactored(249.99, customer);

        // Each object is responsible for its own data — clean, readable output
        System.out.println("Customer Info: " + customer.generateSummary());
        System.out.println("Full Record:   " + order.generateOrderSummary());
    }
}

public class InvoiceCalculator {

    // BEFORE: temp variable hides the meaning of the calculation
    public double calculateTotalBefore(double basePrice, double discountPercent, double taxRate) {
        double discounted = basePrice - (basePrice * discountPercent / 100);
        double tax = discounted * taxRate;
        return discounted + tax;
    }

    // AFTER: each computed value is a query method — intent is clear
    public double calculateTotal(double basePrice, double discountPercent, double taxRate) {
        return applyTax(applyDiscount(basePrice, discountPercent), taxRate);
    }

    private double applyDiscount(double price, double percent) {
        return price - (price * percent / 100);
    }

    private double applyTax(double price, double rate) {
        return price + (price * rate);
    }

    public static void main(String[] args) {
        InvoiceCalculator calc = new InvoiceCalculator();
        double total = calc.calculateTotal(200.0, 10.0, 0.08);
        System.out.printf("Total: $%.2f%n", total);
    }
}