代码重构的六个经典示例

在软件开发的过程中，随着项目的发展和需求的变化，代码也会逐渐变得复杂和难以维护。为了改善代码质量并提高可维护性，代码重构是一项必不可少的工作。代码重构可以通过优化代码结构、增加代码的可读性和可维护性来简化代码。

本文将介绍六个经典的代码重构示例，通过这些示例可以使你更好地理解何时以及如何对代码进行重构。

1. 抽取方法

抽取方法是最常见的代码重构技术之一。当一个方法或函数过于庞大或功能过于复杂时，可以将其中的一部分代码提取出来形成一个新的方法，以提高代码的可读性，并使原方法更加清晰和易于理解。

// Before
public void processOrder() {
  // code for validating order
  // code for updating order status
  // code for sending confirmation email
  // code for generating invoice
}

// After
public void processOrder() {
  validateOrder();
  updateOrderStatus();
  sendConfirmationEmail();
  generateInvoice();
}

private void validateOrder() {
  // code for validating order
}

private void updateOrderStatus() {
  // code for updating order status
}

private void sendConfirmationEmail() {
  // code for sending confirmation email
}

private void generateInvoice() {
  // code for generating invoice
}

2. 合并重复代码

重复代码是导致代码臃肿和难以维护的一个主要原因。可以通过合并重复代码来消除重复的工作，提高代码的可维护性和重用性。合并重复代码可以通过将重复的代码块抽取成方法或使用循环来完成。

// Before
public void printOrder(Order order) {
  System.out.println("Order No: " + order.getOrderNo());
  System.out.println("Customer: " + order.getCustomer());
  System.out.println("Total Amount: " + order.getTotalAmount());
  // print other order details

  // some other code

  System.out.println("Order No: " + order.getOrderNo());
  System.out.println("Customer: " + order.getCustomer());
  System.out.println("Total Amount: " + order.getTotalAmount());
  // print other order details

  // some other code
}

// After
public void printOrder(Order order) {
  printOrderDetails(order);
  // some other code
  printOrderDetails(order);
  // some other code
}

private void printOrderDetails(Order order) {
  System.out.println("Order No: " + order.getOrderNo());
  System.out.println("Customer: " + order.getCustomer());
  System.out.println("Total Amount: " + order.getTotalAmount());
  // print other order details
}

3. 提取接口或父类

当多个类具有共同的行为或功能时，可以将这些共同点提取出来形成一个接口或父类。这样可以使代码更加模块化和可扩展，减少重复代码，并且可以实现多态性，提高代码的灵活性。

// Before
public class Circle {
  private double radius;

  public double getRadius() {
    return radius;
  }

  public double calculateArea() {
    return Math.PI * radius * radius;
  }

  // other methods related to circle
}

public class Square {
  private double side;

  public double getSide() {
    return side;
  }

  public double calculateArea() {
    return side * side;
  }

  // other methods related to square
}

// After
public interface Shape {
  double calculateArea();
}

public class Circle implements Shape {
  private double radius;

  public double getRadius() {
    return radius;
  }

  @Override
  public double calculateArea() {
    return Math.PI * radius * radius;
  }

  // other methods related to circle
}

public class Square implements Shape {
  private double side;

  public double getSide() {
    return side;
  }

  @Override
  public double calculateArea() {
    return side * side;
  }

  // other methods related to square
}

4. 拆分方法

当一个方法或函数过于臃肿或功能过于复杂时，可以将其中的一部分代码拆分成更小的方法，以提高代码的可读性和可维护性。拆分方法可以使代码更模块化，易于理解和修改。

// Before
public void processOrder(Order order) {
  // code for validating order
  // code for updating order status
  // code for sending confirmation email
  // code for generating invoice
  // code for generating reports
}

// After
public void processOrder(Order order) {
  validateOrder(order);
  updateOrderStatus(order);
  sendConfirmationEmail(order);
  generateInvoice(order);
  generateReports(order);
}

private void validateOrder(Order order) {
  // code for validating order
}

private void updateOrderStatus(Order order) {
  // code for updating order status
}

private void sendConfirmationEmail(Order order) {
  // code for sending confirmation email
}

private void generateInvoice(Order order) {
  // code for generating invoice
}

private void generateReports(Order order) {
  // code for generating reports
}

5. 引入设计模式

设计模式是一种经过验证的软件设计原则，可以解决常见的设计问题并提供可重用的解决方案。引入适当的设计模式可以使代码更加清晰、灵活和可扩展，并提高代码的可维护性。

// Before
public class OrderService {
  public void processOrder(Order order) {
    if (order.getStatus() == OrderStatus.NEW) {
      // code for processing new order
    } else if (order.getStatus() == OrderStatus.SHIPPED) {
      // code for processing shipped order
    } else if (order.getStatus() == OrderStatus.DELIVERED) {
      // code for processing delivered order
    }
  }
}

// After
public interface OrderStatusProcessor {
  void process(Order order);
}

public class NewOrderProcessor implements OrderStatusProcessor {
  @Override
  public void process(Order order) {
    // code for processing new order
  }
}

public class ShippedOrderProcessor implements OrderStatusProcessor {
  @Override
  public void process(Order order) {
    // code for processing shipped order
  }
}

public class DeliveredOrderProcessor implements OrderStatusProcessor {
  @Override
  public void process(Order order) {
    // code for processing delivered order
  }
}

public class OrderService {
  private Map<OrderStatus, OrderStatusProcessor> processors;

  public OrderService() {
    processors = new HashMap<>();
    processors.put(OrderStatus.NEW, new NewOrderProcessor());
    processors.put(OrderStatus.SHIPPED, new ShippedOrderProcessor());
    processors.put(OrderStatus.DELIVERED, new DeliveredOrderProcessor());
  }

  public void processOrder(Order order) {
    OrderStatusProcessor processor = processors.get(order.getStatus());
    processor.process(order);
  }
}

6. 移除过度设计

过度设计是指在实现功能时过于复杂化和抽象化问题。过度设计可能会导致代码的冗余和低效，增加维护成本。通过去除不必要的抽象和复杂性，可以使代码更加简洁、高效和易于理解。

// Before
public interface Order {
  void process();
  void cancel();
  void updateStatus(String status);
  void sendNotificationEmail();
  // other unnecessary methods
}

public class OrderImpl implements Order {
  @Override
  public void process() {
    // implementation for processing order
  }

  @Override
  public void cancel() {
    // implementation for order cancellation
  }

  @Override
  public void updateStatus(String status) {
    // implementation for updating order status
  }

  @Override
  public void sendNotificationEmail() {
    // implementation for sending notification email
  }

  // unnecessary methods with empty or default implementation
}

// After
public interface Order {
  void process();
}

public class OrderImpl implements Order {
  @Override
  public void process() {
    // implementation for processing order
  }
}

以上是六个经典的代码重构示例，通过这些示例可以改善代码的可读性、可维护性和重用性。重构代码需要谨慎，并在保持代码功能完整性的前提下进行。通过合理地应用代码重构技术，可以提高代码质量和开发效率。

本文来自极简博客，作者：梦里花落，转载请注明原文链接：代码重构的六个经典示例