[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":88,"_72":89,"_35":90},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",7,"title","Extract Method, Class, and Interface","slug","clean-code-part-6-extract-patterns","excerpt","Master the three fundamental extraction refactorings (Method, Class, Interface) with step-by-step techniques for breaking down complex code into testable components.","# Advanced Clean Code Patterns Part 6: Extract Patterns (Method, Class, Interface)\n\nExtraction is the most fundamental refactoring skill. When code is too long, too complex, or has too many responsibilities, extraction is usually the answer. This article covers the three core extractions - Method, Class, and Interface - with step-by-step techniques and real examples.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Patterns Covered | Extract Method, Extract Class, Extract Interface |\n| Primary Use | Reducing complexity, improving cohesion |\n| IDE Support | Excellent (all major IDEs) |\n| Risk Level | Low (behavior-preserving) |\n| Time Investment | Minutes per extraction |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Extract Method** with proper parameter and return handling\n- **Extract Class** by identifying responsibility boundaries\n- **Extract Interface** for testability and flexibility\n- **Introduce Parameter Object** for long parameter lists\n- **Safe extraction** techniques that preserve behavior\n- **IDE shortcuts** for automated extraction\n\n---\n\n## 🔥 Production Story: The 1,000-Line Method Tamed\n\nA fintech company had a `TransactionProcessor` method that had grown to 1,047 lines over 5 years. Nobody dared touch it because:\n\n- Any change took 2-3 days to understand the code\n- Tests took 15 minutes to run\n- 40% of production bugs originated from this method\n\nThe team spent 2 weeks systematically extracting:\n- **23 methods** from the original monolith\n- **4 collaborating classes** (Validator, Calculator, Persister, Notifier)\n- **3 interfaces** for external dependencies\n\n**Results:**\n- Average method: 18 lines (was: 1,047)\n- Test runtime: 45 seconds (was: 15 minutes)\n- Bug rate: Dropped 70% in following quarter\n- Developer satisfaction: \"I actually understand this code now\"\n\n---\n\n## 🧠 Mental Model: The Extraction Decision Tree\n\n```text\nCode needs simplification?\n│\n├── Method too long? (> 20 lines)\n│ └── EXTRACT METHOD\n│ Split into named, focused methods\n│\n├── Class too large? (> 200 lines, multiple responsibilities)\n│ └── EXTRACT CLASS\n│ Create new class for cohesive responsibility\n│\n├── Need to swap implementations or mock for testing?\n│ └── EXTRACT INTERFACE\n│ Define contract, allow substitution\n│\n├── Too many parameters? (> 4)\n│ └── INTRODUCE PARAMETER OBJECT\n│ Group related parameters into object\n│\n└── Data appears together in multiple places?\n └── EXTRACT VALUE OBJECT\n Create domain concept object\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Extract Method\n\n**When to use:**\n- Method longer than 20 lines\n- Code block has a comment explaining what it does\n- Same code appears in multiple places\n- Code block operates at different abstraction level\n\n#### Step-by-Step Process\n\n**Step 1: Identify the code block**\n\n```java\npublic void processOrder(Order order) {\n // === VALIDATION BLOCK - candidate for extraction ===\n if (order == null) {\n throw new IllegalArgumentException(\"Order cannot be null\");\n }\n if (order.getItems() == null || order.getItems().isEmpty()) {\n throw new ValidationException(\"Order must have items\");\n }\n for (OrderItem item : order.getItems()) {\n if (item.getQuantity() <= 0) {\n throw new ValidationException(\"Invalid quantity for: \" + item.getProductId());\n }\n if (item.getPrice().compareTo(BigDecimal.ZERO) < 0) {\n throw new ValidationException(\"Invalid price for: \" + item.getProductId());\n }\n }\n // === END VALIDATION BLOCK ===\n\n // ... rest of processing\n}\n```\n\n**Step 2: Identify inputs and outputs**\n\n```text\nInputs: order\nOutputs: none (throws exception on failure)\nSide effects: none\n```\n\n**Step 3: Extract and name**\n\n```java\npublic void processOrder(Order order) {\n validateOrder(order); // Clear intent\n // ... rest of processing\n}\n\nprivate void validateOrder(Order order) {\n if (order == null) {\n throw new IllegalArgumentException(\"Order cannot be null\");\n }\n if (order.getItems() == null || order.getItems().isEmpty()) {\n throw new ValidationException(\"Order must have items\");\n }\n for (OrderItem item : order.getItems()) {\n validateOrderItem(item); // Further extraction!\n }\n}\n\nprivate void validateOrderItem(OrderItem item) {\n if (item.getQuantity() <= 0) {\n throw new ValidationException(\"Invalid quantity for: \" + item.getProductId());\n }\n if (item.getPrice().compareTo(BigDecimal.ZERO) < 0) {\n throw new ValidationException(\"Invalid price for: \" + item.getProductId());\n }\n}\n```\n\n#### Handling Complex Extractions\n\n**Multiple return values - use a result object:**\n\n```java\n// ❌ Before: Can't easily extract - multiple outputs\npublic void processPayment(Order order) {\n BigDecimal subtotal = BigDecimal.ZERO;\n BigDecimal tax = BigDecimal.ZERO;\n BigDecimal discount = BigDecimal.ZERO;\n\n for (OrderItem item : order.getItems()) {\n BigDecimal lineTotal = item.getPrice()\n .multiply(BigDecimal.valueOf(item.getQuantity()));\n subtotal = subtotal.add(lineTotal);\n }\n\n tax = subtotal.multiply(TAX_RATE);\n\n if (order.getCustomer().isVip()) {\n discount = subtotal.multiply(VIP_DISCOUNT);\n }\n\n // Use subtotal, tax, discount...\n}\n\n// ✅ After: Extract with result object\npublic void processPayment(Order order) {\n OrderTotals totals = calculateTotals(order);\n // Use totals.subtotal(), totals.tax(), totals.discount()\n}\n\nprivate record OrderTotals(BigDecimal subtotal, BigDecimal tax, BigDecimal discount) {\n public BigDecimal total() {\n return subtotal.add(tax).subtract(discount);\n }\n}\n\nprivate OrderTotals calculateTotals(Order order) {\n BigDecimal subtotal = calculateSubtotal(order);\n BigDecimal tax = calculateTax(subtotal);\n BigDecimal discount = calculateDiscount(order, subtotal);\n return new OrderTotals(subtotal, tax, discount);\n}\n```\n\n**Local variables modified - return the value:**\n\n```java\n// ❌ Before: Local variable modified in block\npublic String format(String text) {\n String result = text;\n\n // Block modifies 'result'\n result = result.trim();\n result = result.toLowerCase();\n result = result.replaceAll(\"\\\\s+\", \" \");\n\n return result;\n}\n\n// ✅ After: Chain returns\npublic String format(String text) {\n return normalize(text);\n}\n\nprivate String normalize(String text) {\n return text.trim()\n .toLowerCase()\n .replaceAll(\"\\\\s+\", \" \");\n}\n```\n\n---\n\n### Pattern 2: Extract Class\n\n**When to use:**\n- Class has multiple distinct responsibilities\n- Groups of methods use different subsets of fields\n- Class name includes \"And\" or is vague (\"Manager\", \"Handler\", \"Util\")\n- LCOM metric suggests low cohesion\n\n#### Step-by-Step Process\n\n**Step 1: Identify responsibility clusters**\n\n```java\npublic class OrderService {\n private OrderRepository orderRepository;\n private PaymentGateway paymentGateway;\n private EmailService emailService;\n private InventoryService inventoryService;\n\n // CLUSTER 1: Order CRUD\n public Order createOrder(OrderRequest request) { ... }\n public Order getOrder(Long id) { ... }\n public void updateOrder(Order order) { ... }\n\n // CLUSTER 2: Payment processing\n public PaymentResult processPayment(Order order) { ... }\n public void refundPayment(Order order) { ... }\n private boolean validatePaymentMethod(PaymentMethod method) { ... }\n\n // CLUSTER 3: Notifications\n public void sendOrderConfirmation(Order order) { ... }\n public void sendShippingNotification(Order order) { ... }\n private String buildEmailContent(Order order) { ... }\n\n // CLUSTER 4: Inventory\n public void reserveInventory(Order order) { ... }\n public void releaseInventory(Order order) { ... }\n}\n```\n\n**Step 2: Create new classes for each cluster**\n\n```java\n// ✅ After: Focused services\n\n@Service\npublic class OrderService {\n private final OrderRepository orderRepository;\n private final OrderPaymentService paymentService;\n private final OrderNotificationService notificationService;\n private final OrderInventoryService inventoryService;\n\n public Order createOrder(OrderRequest request) {\n Order order = buildOrder(request);\n inventoryService.reserve(order);\n Order saved = orderRepository.save(order);\n notificationService.sendConfirmation(saved);\n return saved;\n }\n\n public Order getOrder(Long id) {\n return orderRepository.findById(id)\n .orElseThrow(() -> new OrderNotFoundException(id));\n }\n}\n\n@Service\npublic class OrderPaymentService {\n private final PaymentGateway paymentGateway;\n\n public PaymentResult processPayment(Order order) { ... }\n public void refundPayment(Order order) { ... }\n}\n\n@Service\npublic class OrderNotificationService {\n private final EmailService emailService;\n\n public void sendConfirmation(Order order) { ... }\n public void sendShippingNotification(Order order) { ... }\n}\n\n@Service\npublic class OrderInventoryService {\n private final InventoryService inventoryService;\n\n public void reserve(Order order) { ... }\n public void release(Order order) { ... }\n}\n```\n\n**Step 3: Update dependencies and callers**\n\n```java\n// Before: Controller used monolithic service\n@RestController\npublic class OrderController {\n private final OrderService orderService;\n\n @PostMapping(\"/orders/{id}/refund\")\n public void refund(@PathVariable Long id) {\n Order order = orderService.getOrder(id);\n orderService.refundPayment(order); // Was on OrderService\n }\n}\n\n// After: Controller uses focused services\n@RestController\npublic class OrderController {\n private final OrderService orderService;\n private final OrderPaymentService paymentService;\n\n @PostMapping(\"/orders/{id}/refund\")\n public void refund(@PathVariable Long id) {\n Order order = orderService.getOrder(id);\n paymentService.refundPayment(order); // Focused service\n }\n}\n```\n\n---\n\n### Pattern 3: Extract Interface\n\n**When to use:**\n- Need to mock a class for testing\n- Multiple implementations possible (now or future)\n- Want to define a contract separate from implementation\n- Breaking dependency cycles\n\n#### For Testing\n\n```java\n// ❌ Before: Hard to test - concrete dependency\n@Service\npublic class OrderService {\n private final StripeClient stripeClient; // Concrete!\n\n public PaymentResult charge(Order order) {\n // Can't test without real Stripe credentials\n return stripeClient.charge(order.getTotal());\n }\n}\n\n// ✅ After: Extract interface for testing\npublic interface PaymentGateway {\n PaymentResult charge(Money amount);\n RefundResult refund(PaymentId paymentId);\n}\n\n@Service\npublic class StripePaymentGateway implements PaymentGateway {\n private final StripeClient stripeClient;\n\n @Override\n public PaymentResult charge(Money amount) {\n return stripeClient.charge(amount.getAmount());\n }\n}\n\n@Service\npublic class OrderService {\n private final PaymentGateway paymentGateway; // Interface!\n\n public PaymentResult charge(Order order) {\n return paymentGateway.charge(order.getTotal());\n }\n}\n\n// Test\n@Test\nvoid chargeOrder_callsPaymentGateway() {\n PaymentGateway mockGateway = mock(PaymentGateway.class);\n when(mockGateway.charge(any())).thenReturn(PaymentResult.success());\n\n OrderService service = new OrderService(mockGateway);\n service.charge(testOrder);\n\n verify(mockGateway).charge(testOrder.getTotal());\n}\n```\n\n#### For Multiple Implementations\n\n```java\n// Interface defines contract\npublic interface NotificationSender {\n void send(Notification notification);\n boolean supports(NotificationType type);\n}\n\n// Multiple implementations\n@Component\npublic class EmailNotificationSender implements NotificationSender {\n @Override\n public boolean supports(NotificationType type) {\n return type == NotificationType.EMAIL;\n }\n\n @Override\n public void send(Notification notification) {\n // Email logic\n }\n}\n\n@Component\npublic class SmsNotificationSender implements NotificationSender {\n @Override\n public boolean supports(NotificationType type) {\n return type == NotificationType.SMS;\n }\n\n @Override\n public void send(Notification notification) {\n // SMS logic\n }\n}\n\n// Usage\n@Service\npublic class NotificationService {\n private final List senders;\n\n public void send(Notification notification) {\n senders.stream()\n .filter(s -> s.supports(notification.getType()))\n .findFirst()\n .orElseThrow(() -> new UnsupportedNotificationException())\n .send(notification);\n }\n}\n```\n\n---\n\n### Pattern 4: Introduce Parameter Object\n\n**When to use:**\n- Method has more than 4 parameters\n- Same group of parameters appears in multiple methods\n- Parameters are logically related\n\n```java\n// ❌ Before: Long parameter list\npublic Report generateReport(\n LocalDate startDate,\n LocalDate endDate,\n String department,\n boolean includeSubDepartments,\n ReportFormat format,\n String sortBy,\n SortOrder sortOrder,\n int pageSize,\n int pageNumber) {\n // ...\n}\n\n// ✅ After: Parameter Object\npublic record ReportRequest(\n DateRange dateRange,\n DepartmentFilter departmentFilter,\n ReportFormat format,\n SortOptions sortOptions,\n Pagination pagination\n) {\n // Builder for convenience\n public static Builder builder() {\n return new Builder();\n }\n\n public static class Builder {\n private DateRange dateRange;\n private DepartmentFilter departmentFilter;\n private ReportFormat format = ReportFormat.PDF;\n private SortOptions sortOptions = SortOptions.DEFAULT;\n private Pagination pagination = Pagination.unpaged();\n\n public Builder dateRange(LocalDate start, LocalDate end) {\n this.dateRange = new DateRange(start, end);\n return this;\n }\n\n public ReportRequest build() {\n Objects.requireNonNull(dateRange, \"Date range required\");\n return new ReportRequest(dateRange, departmentFilter,\n format, sortOptions, pagination);\n }\n }\n}\n\npublic record DateRange(LocalDate start, LocalDate end) {\n public DateRange {\n if (end.isBefore(start)) {\n throw new IllegalArgumentException(\"End must be after start\");\n }\n }\n}\n\n// Usage\nReport report = reportService.generate(\n ReportRequest.builder()\n .dateRange(startDate, endDate)\n .format(ReportFormat.PDF)\n .build()\n);\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Extracting Too Little\n\n```java\n// ❌ Over-extracted: Too many tiny methods\npublic void process(Order order) {\n checkNotNull(order);\n checkHasItems(order);\n checkItemsValid(order);\n calculateSubtotal(order);\n calculateTax(order);\n calculateDiscount(order);\n buildInvoice(order);\n saveInvoice(order);\n sendNotification(order);\n}\n// 9 method calls, each 1-2 lines - hard to follow!\n\n// ✅ Balanced: Meaningful abstractions\npublic void process(Order order) {\n validateOrder(order);\n Invoice invoice = calculateInvoice(order);\n saveAndNotify(invoice);\n}\n```\n\n### Mistake 2: Passing Object When Part Suffices\n\n```java\n// ❌ Passes whole object, uses one field\nprivate BigDecimal calculateShipping(Order order) {\n return order.getWeight().multiply(RATE_PER_KG);\n}\n\n// ✅ Pass only what's needed\nprivate BigDecimal calculateShipping(Weight weight) {\n return weight.multiply(RATE_PER_KG);\n}\n```\n\n### Mistake 3: Extracting Without Good Names\n\n```java\n// ❌ Unclear names\nprivate void doStep1(Order order) { ... }\nprivate void handleData(Order order) { ... }\nprivate void processStuff(Order order) { ... }\n\n// ✅ Names reveal intent\nprivate void validateInventoryAvailability(Order order) { ... }\nprivate void applyPromotionalDiscounts(Order order) { ... }\nprivate void reserveInventory(Order order) { ... }\n```\n\n---\n\n## 🐛 Debug This: The Extraction That Broke Everything\n\nA developer reports: \"I extracted a method to make the code cleaner, but now random tests are failing. I didn't change any logic!\"\n\n```java\n// Before extraction - worked fine\npublic class OrderProcessor {\n public void processOrder(Order order) {\n // Step 1: Validate\n if (order.getItems().isEmpty()) {\n order.setStatus(\"INVALID\");\n return;\n }\n\n // Step 2: Calculate (modifies order in place)\n BigDecimal total = BigDecimal.ZERO;\n for (OrderItem item : order.getItems()) {\n if (item.getPrice() == null) {\n item.setPrice(lookupPrice(item.getProductId()));\n }\n total = total.add(item.getPrice());\n }\n order.setTotal(total);\n\n order.setStatus(\"PROCESSED\");\n }\n}\n\n// After extraction - fails intermittently\npublic class OrderProcessor {\n public void processOrder(Order order) {\n if (!isValid(order)) {\n order.setStatus(\"INVALID\");\n return;\n }\n\n order.setTotal(calculateTotal(order)); // Bug hides here!\n order.setStatus(\"PROCESSED\");\n }\n\n private boolean isValid(Order order) {\n return !order.getItems().isEmpty();\n }\n\n private BigDecimal calculateTotal(Order order) {\n return order.getItems().stream()\n .map(item -> item.getPrice()) // NullPointerException!\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n }\n}\n```\n\n**Why do tests fail after \"clean\" extraction? Find the missing behavior!**\n\n---\n\n**✅ Solution:**\n\nThe extraction **lost a side effect** - the original code filled in missing prices:\n\n```java\nif (item.getPrice() == null) {\n item.setPrice(lookupPrice(item.getProductId()));\n}\n```\n\nThis side effect was embedded in the calculation loop. When extracted to a stream, this price-lookup logic was dropped.\n\n**Problems:**\n1. **Hidden side effect** - calculation also modified item prices\n2. **Incomplete extraction** - functionality was lost, not just reorganized\n3. **Mixed concerns** - calculation + data fixing in one loop\n\n**The lesson:** Before extracting, identify ALL behaviors in the code block. Side effects are easy to miss, especially when embedded in loops. The correct extraction would be:\n\n```java\nprivate void ensurePricesLoaded(Order order) {\n order.getItems().stream()\n .filter(item -> item.getPrice() == null)\n .forEach(item -> item.setPrice(lookupPrice(item.getProductId())));\n}\n\npublic void processOrder(Order order) {\n if (!isValid(order)) { order.setStatus(\"INVALID\"); return; }\n ensurePricesLoaded(order); // Explicit!\n order.setTotal(calculateTotal(order));\n order.setStatus(\"PROCESSED\");\n}\n```\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Extract Methods\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Refactor this method by extracting meaningful methods.\n\n```java\npublic Invoice createInvoice(Order order, Customer customer) {\n // Validation\n if (order == null) throw new IllegalArgumentException(\"Order required\");\n if (customer == null) throw new IllegalArgumentException(\"Customer required\");\n if (order.getItems().isEmpty()) throw new IllegalArgumentException(\"Order empty\");\n\n // Calculate totals\n BigDecimal subtotal = BigDecimal.ZERO;\n for (OrderItem item : order.getItems()) {\n subtotal = subtotal.add(item.getPrice().multiply(\n BigDecimal.valueOf(item.getQuantity())));\n }\n\n BigDecimal tax = subtotal.multiply(new BigDecimal(\"0.21\"));\n BigDecimal discount = BigDecimal.ZERO;\n if (customer.isVip()) {\n discount = subtotal.multiply(new BigDecimal(\"0.1\"));\n }\n BigDecimal total = subtotal.add(tax).subtract(discount);\n\n // Build invoice\n Invoice invoice = new Invoice();\n invoice.setOrderId(order.getId());\n invoice.setCustomerId(customer.getId());\n invoice.setSubtotal(subtotal);\n invoice.setTax(tax);\n invoice.setDiscount(discount);\n invoice.setTotal(total);\n invoice.setCreatedAt(LocalDateTime.now());\n\n // Save and notify\n invoiceRepository.save(invoice);\n emailService.sendInvoice(customer.getEmail(), invoice);\n\n return invoice;\n}\n```\n\n**✅ Solution:**\n\n```java\npublic Invoice createInvoice(Order order, Customer customer) {\n validateInputs(order, customer);\n InvoiceCalculation calculation = calculateInvoice(order, customer);\n Invoice invoice = buildInvoice(order, customer, calculation);\n saveAndNotify(invoice, customer);\n return invoice;\n}\n\nprivate void validateInputs(Order order, Customer customer) {\n if (order == null) throw new IllegalArgumentException(\"Order required\");\n if (customer == null) throw new IllegalArgumentException(\"Customer required\");\n if (order.getItems().isEmpty()) throw new IllegalArgumentException(\"Order empty\");\n}\n\nprivate InvoiceCalculation calculateInvoice(Order order, Customer customer) {\n BigDecimal subtotal = order.getItems().stream()\n .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n BigDecimal tax = subtotal.multiply(TAX_RATE);\n BigDecimal discount = customer.isVip() ? subtotal.multiply(VIP_DISCOUNT) : BigDecimal.ZERO;\n return new InvoiceCalculation(subtotal, tax, discount);\n}\n\nprivate Invoice buildInvoice(Order order, Customer customer, InvoiceCalculation calc) {\n return Invoice.builder()\n .orderId(order.getId())\n .customerId(customer.getId())\n .subtotal(calc.subtotal())\n .tax(calc.tax())\n .discount(calc.discount())\n .total(calc.total())\n .createdAt(LocalDateTime.now())\n .build();\n}\n\nprivate void saveAndNotify(Invoice invoice, Customer customer) {\n invoiceRepository.save(invoice);\n emailService.sendInvoice(customer.getEmail(), invoice);\n}\n```\n\n---\n\n### Exercise 2: Extract Class\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Split this class into focused classes.\n\n```java\npublic class UserManager {\n private UserRepository userRepository;\n private PasswordEncoder passwordEncoder;\n private EmailService emailService;\n private AuditLogger auditLogger;\n\n public User createUser(UserRequest request) { ... }\n public User getUser(Long id) { ... }\n public void updateUser(User user) { ... }\n public void deleteUser(Long id) { ... }\n\n public boolean authenticate(String username, String password) { ... }\n public void changePassword(Long userId, String oldPass, String newPass) { ... }\n public String resetPassword(String email) { ... }\n\n public void sendWelcomeEmail(User user) { ... }\n public void sendPasswordResetEmail(User user, String token) { ... }\n\n public void logUserAction(User user, String action) { ... }\n public List getUserAuditTrail(Long userId) { ... }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Split by responsibility\n@Service\npublic class UserCrudService {\n private final UserRepository userRepository;\n public User createUser(UserRequest request) { ... }\n public User getUser(Long id) { ... }\n public void updateUser(User user) { ... }\n public void deleteUser(Long id) { ... }\n}\n\n@Service\npublic class AuthenticationService {\n private final UserRepository userRepository;\n private final PasswordEncoder passwordEncoder;\n public boolean authenticate(String username, String password) { ... }\n public void changePassword(Long userId, String oldPass, String newPass) { ... }\n public String resetPassword(String email) { ... }\n}\n\n@Service\npublic class UserNotificationService {\n private final EmailService emailService;\n public void sendWelcomeEmail(User user) { ... }\n public void sendPasswordResetEmail(User user, String token) { ... }\n}\n\n@Service\npublic class UserAuditService {\n private final AuditLogger auditLogger;\n public void logUserAction(User user, String action) { ... }\n public List getUserAuditTrail(Long userId) { ... }\n}\n```\n\n---\n\n### Exercise 3: Extract Interface\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Extract an interface to enable polymorphism.\n\n```java\npublic class PaymentProcessor {\n public PaymentResult process(Payment payment) {\n if (payment.getType().equals(\"CREDIT_CARD\")) {\n // 30 lines of credit card processing\n } else if (payment.getType().equals(\"PAYPAL\")) {\n // 30 lines of PayPal processing\n } else if (payment.getType().equals(\"BANK_TRANSFER\")) {\n // 30 lines of bank transfer processing\n }\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic interface PaymentMethod {\n PaymentResult process(Payment payment);\n boolean supports(String paymentType);\n}\n\n@Component\npublic class CreditCardPayment implements PaymentMethod {\n public boolean supports(String type) { return \"CREDIT_CARD\".equals(type); }\n public PaymentResult process(Payment payment) { /* ... */ }\n}\n\n@Component\npublic class PayPalPayment implements PaymentMethod {\n public boolean supports(String type) { return \"PAYPAL\".equals(type); }\n public PaymentResult process(Payment payment) { /* ... */ }\n}\n\n@Service\npublic class PaymentProcessor {\n private final List methods;\n\n public PaymentResult process(Payment payment) {\n return methods.stream()\n .filter(m -> m.supports(payment.getType()))\n .findFirst()\n .orElseThrow(() -> new UnsupportedPaymentException(payment.getType()))\n .process(payment);\n }\n}\n```\n\n---\n\n### Exercise 4: Extract Superclass\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Identify common behavior and extract a superclass.\n\n```java\npublic class EmailNotification {\n private String recipient;\n private String subject;\n private String body;\n\n public void send() {\n validate();\n log(\"Sending email to \" + recipient);\n sendEmail();\n log(\"Email sent successfully\");\n recordMetrics(\"email\");\n }\n}\n\npublic class SmsNotification {\n private String phoneNumber;\n private String message;\n\n public void send() {\n validate();\n log(\"Sending SMS to \" + phoneNumber);\n sendSms();\n log(\"SMS sent successfully\");\n recordMetrics(\"sms\");\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Template Method pattern\npublic abstract class Notification {\n protected abstract void validate();\n protected abstract void doSend();\n protected abstract String getRecipientInfo();\n protected abstract String getType();\n\n public final void send() {\n validate();\n log(\"Sending \" + getType() + \" to \" + getRecipientInfo());\n doSend();\n log(getType() + \" sent successfully\");\n recordMetrics(getType());\n }\n}\n\npublic class EmailNotification extends Notification {\n private String recipient;\n private String subject;\n private String body;\n\n protected void validate() { /* email validation */ }\n protected void doSend() { sendEmail(); }\n protected String getRecipientInfo() { return recipient; }\n protected String getType() { return \"email\"; }\n}\n\npublic class SmsNotification extends Notification {\n private String phoneNumber;\n private String message;\n\n protected void validate() { /* sms validation */ }\n protected void doSend() { sendSms(); }\n protected String getRecipientInfo() { return phoneNumber; }\n protected String getType() { return \"sms\"; }\n}\n```\n\n---\n\n### Exercise 5: Recognize Extraction Opportunities\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Identify all extraction opportunities and implement them.\n\n```java\npublic class ReportService {\n public byte[] generateMonthlyReport(int month, int year) {\n // Validate\n if (month < 1 || month > 12) throw new IllegalArgumentException(\"Invalid month\");\n if (year < 2000 || year > 2100) throw new IllegalArgumentException(\"Invalid year\");\n\n // Query data\n LocalDate start = LocalDate.of(year, month, 1);\n LocalDate end = start.plusMonths(1).minusDays(1);\n List transactions = transactionRepository\n .findByDateBetween(start, end);\n\n // Group by category\n Map> byCategory = transactions.stream()\n .collect(Collectors.groupingBy(Transaction::getCategory));\n\n // Build report\n StringBuilder sb = new StringBuilder();\n sb.append(\"Monthly Report: \").append(month).append(\"/\").append(year).append(\"\\n\");\n sb.append(\"Generated: \").append(LocalDateTime.now()).append(\"\\n\\n\");\n\n for (Map.Entry> entry : byCategory.entrySet()) {\n sb.append(\"Category: \").append(entry.getKey()).append(\"\\n\");\n BigDecimal total = entry.getValue().stream()\n .map(Transaction::getAmount)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n sb.append(\"Total: \").append(total).append(\"\\n\\n\");\n }\n\n // Convert to PDF\n Document doc = new Document();\n PdfWriter.getInstance(doc, new ByteArrayOutputStream());\n doc.open();\n doc.add(new Paragraph(sb.toString()));\n doc.close();\n\n return ((ByteArrayOutputStream) doc.getOutputStream()).toByteArray();\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Extract each responsibility\npublic record DateRange(LocalDate start, LocalDate end) {\n public static DateRange forMonth(int month, int year) {\n LocalDate start = LocalDate.of(year, month, 1);\n return new DateRange(start, start.plusMonths(1).minusDays(1));\n }\n}\n\npublic class MonthlyReportValidator {\n public void validate(int month, int year) {\n if (month < 1 || month > 12) throw new IllegalArgumentException(\"Invalid month\");\n if (year < 2000 || year > 2100) throw new IllegalArgumentException(\"Invalid year\");\n }\n}\n\npublic class TransactionAggregator {\n public Map sumByCategory(List transactions) {\n return transactions.stream()\n .collect(Collectors.groupingBy(\n Transaction::getCategory,\n Collectors.reducing(BigDecimal.ZERO, Transaction::getAmount, BigDecimal::add)\n ));\n }\n}\n\npublic class ReportContentBuilder {\n public String build(int month, int year, Map totals) {\n StringBuilder sb = new StringBuilder();\n sb.append(\"Monthly Report: \").append(month).append(\"/\").append(year).append(\"\\n\");\n totals.forEach((cat, total) -> sb.append(cat).append(\": \").append(total).append(\"\\n\"));\n return sb.toString();\n }\n}\n\npublic class PdfGenerator {\n public byte[] generate(String content) { /* PDF generation */ }\n}\n\n@Service\npublic class ReportService {\n private final MonthlyReportValidator validator;\n private final TransactionRepository transactionRepository;\n private final TransactionAggregator aggregator;\n private final ReportContentBuilder contentBuilder;\n private final PdfGenerator pdfGenerator;\n\n public byte[] generateMonthlyReport(int month, int year) {\n validator.validate(month, year);\n DateRange range = DateRange.forMonth(month, year);\n List transactions = transactionRepository.findByDateBetween(range.start(), range.end());\n Map totals = aggregator.sumByCategory(transactions);\n String content = contentBuilder.build(month, year, totals);\n return pdfGenerator.generate(content);\n }\n}\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Question #1: How do you decide what to extract?\n\n**Strong answer:**\n\nI look for these signals:\n\n1. **Comments as section headers** - \"// Calculate totals\" → Extract `calculateTotals()`\n2. **Different abstraction levels** - High-level flow mixed with low-level details\n3. **Repeated code patterns** - Same 3 lines in multiple places\n4. **Conditional blocks** - Complex if/else often extracts well\n5. **Loop bodies** - Loop setup + iteration + body can be separated\n\nThe goal is: after extraction, the original method reads like a high-level summary.\n\n---\n\n### Question #2: When should you extract an interface vs just use the class?\n\n**Strong answer:**\n\nExtract interface when:\n- **Testing requires mocking** - Interface makes stubbing easy\n- **Multiple implementations exist** - Now or planned soon\n- **Dependency inversion needed** - High-level shouldn't depend on low-level\n- **Plugin architecture** - Allow extension without modification\n\nDon't extract when:\n- Only one implementation will ever exist\n- Class is a simple data object\n- Testing can use the real class\n- It's an internal implementation detail\n\n---\n\n### Question #3: How do you handle extraction in legacy code without tests?\n\n**Strong answer:**\n\nSafe extraction process for legacy code:\n\n1. **Characterization test first** - Capture current behavior\n```java\n@Test\nvoid characterize_existingBehavior() {\n String result = legacyMethod(testInput);\n assertEquals(\"whatever it returns\", result); // Document, don't judge\n}\n```\n\n2. **Extract mechanically** - Use IDE refactoring, don't modify logic\n\n3. **Run characterization tests** - Must still pass\n\n4. **Add focused tests** - Now that methods are smaller\n\n5. **Commit after each extraction** - Easy rollback if something breaks\n\n---\n\n## 📝 Summary & Key Takeaways\n\n### Extraction Quick Reference\n\n| Pattern | When to Use | IDE Shortcut |\n|---------|-------------|--------------|\n| Extract Method | Long method, duplicated code | `Ctrl+Alt+M` |\n| Extract Class | Low cohesion, multiple responsibilities | Refactor menu |\n| Extract Interface | Need mock, multiple implementations | `Ctrl+Shift+Alt+T` |\n| Parameter Object | 4+ parameters, related data | Refactor menu |\n\n### Extraction Checklist\n\nBefore extracting:\n- [ ] Tests exist (or write characterization tests)\n- [ ] Clear name for extracted element\n- [ ] Identified inputs and outputs\n- [ ] Understand all side effects\n\nAfter extracting:\n- [ ] Original code reads as high-level summary\n- [ ] Extracted element is cohesive\n- [ ] Names reveal intent\n- [ ] Tests still pass\n\n---\n\n## 🏁 Conclusion\n\nExtraction is the workhorse of refactoring. Master these patterns and you'll be able to tame any complex codebase one extraction at a time.\n\n**Key insight:** Good extraction makes code read like well-written prose - the main method tells the story, helper methods provide the details.\n\n**Your next step:** Continue to Part 7 (Replace Conditional with Polymorphism) to learn how to eliminate complex switch/if-else chains.\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Extract Method step-by-step diagram | 5 min |\n| Day 3 | Redo Exercise 1 (Extract Methods from createInvoice) | 15 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (side effect preservation) | 10 min |\n| Day 30 | Apply Extract Method to one long method in your project | 15 min |\n\n---\n\n*Next in series: [Part 7: Replace Conditional with Polymorphism]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.703089Z","createdAt","2026-06-10T07:19:24.704123Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",17,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",6,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},31,"Refactoring","refactoring",38,"Extract Method","extract-method",39,"Extract Class","extract-class",40,"Decomposition","decomposition",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]