Java代码重构技巧：6个方法论，打造高质量代码

# 1. Java代码重构概述

在软件开发领域，代码重构是一种持续的过程，它涉及对现有代码的改进而不改变其外部行为。这一过程不仅有助于提高代码的可读性、可维护性，还能提升系统的整体设计质量。本章将对Java代码重构进行概述，奠定全文的基础。

## 重构的重要性

重构是软件开发的一部分，旨在优化系统结构而不改变功能。在Java这种面向对象的语言中，重构可以帮助开发者清理过时的代码、减少冗余，并使设计更符合现代编码标准。通过重构，团队可以更好地适应未来的需求变化，降低技术债务。

## 重构的基本原则

重构的原则可以归纳为小步修改、频繁集成和持续测试。通过逐步重构，我们可以确保每次修改都在控制之中，而频繁的集成确保了变更不会引入新的错误。持续测试，无论是单元测试还是集成测试，都是确保重构不破坏现有功能的关键。

接下来，我们将深入探讨如何识别和处理代码中的坏味道，这是重构的首要步骤。

# 2. 代码坏味道识别与处理

## 2.1 识别代码中的坏味道

在软件开发过程中，"代码坏味道"是代码质量低下的直观表现，它们可能导致代码难以理解、难以维护和扩展。下面将详细探讨常见的几种坏味道。

### 2.1.1 长方法

长方法通常包含复杂的逻辑和过长的代码行数，这使得理解、测试和维护变得异常困难。

#### 问题识别

- 方法中的代码行数超过了25行。
- 方法内嵌套了多层循环或条件判断。
- 方法内有多个职责，例如数据处理、业务逻辑、数据校验等。

#### 示例代码

public class OrderService {
    public void processOrder(Order order) {
        if (order != null && order.isValid()) {
            List<Item> items = order.getItems();
            double totalPrice = 0;
            for (Item item : items) {
                if (item.getQuantity() > 0) {
                    double price = item.getPrice();
                    double discount = calculateDiscount(item);
                    totalPrice += price * (1 - discount) * item.getQuantity();
                }
            }
            if (totalPrice > 1000) {
                applyBonus(order);
            }
            order.setTotalPrice(totalPrice);
            sendOrderConfirmationEmail(order);
        }
    }
    private double calculateDiscount(Item item) {
        // ...
    }
    private void applyBonus(Order order) {
        // ...
    }
    private void sendOrderConfirmationEmail(Order order) {
        // ...
    }
}

### 2.1.2 大类

大类含有大量的方法和属性，它们可能会使得类变得复杂和难以管理。

#### 问题识别

- 类包含超过10个方法或属性。
- 类承担了过多的职责，与多个其他类存在强耦合。
- 类的修改会影响到大量其他类。

#### 示例代码

public class BigClass {
    private String property1;
    private String property2;
    // ...
    private String property10;
    public void method1() {
        // ...
    }
    public void method2() {
        // ...
    }
    // ...
    public void method15() {
        // ...
    }
}

### 2.1.3 重复代码

重复代码意味着相似的逻辑在多处出现，这会增加维护成本，并可能造成不一致的错误。

#### 问题识别

- 在不同的类或方法中发现了相同或相似的代码段。
- 某些代码段在多处被复制粘贴。

#### 示例代码

public void processOrder(Order order) {
    // ... [重复代码开始]
    if (order.isEligibleForDiscount()) {
        double discount = calculateDiscount(order);
        order.applyDiscount(discount);
    }
    // ... [重复代码结束]
}

public void processRefund(Order order) {
    // ... [重复代码开始]
    if (order.isEligibleForDiscount()) {
        double discount = calculateDiscount(order);
        order.applyRefund(discount);
    }
    // ... [重复代码结束]
}

## 2.2 代码坏味道的处理策略

在识别出代码坏味道之后，重要的是采取合适的重构策略，使代码质量得到提升。这里介绍三种常用的处理策略。

### 2.2.1 提取方法重构

提取方法是将一段大方法中的某部分逻辑抽离出来形成新的方法，以减少原方法的复杂度。

#### 重构步骤

- 确定要提取的方法逻辑。
- 在原方法中创建一个新方法。
- 将原方法中的逻辑块移动到新方法中。
- 在原方法中调用新创建的方法。

#### 示例代码

public class OrderService {
    public void processOrder(Order order) {
        if (order != null && order.isValid()) {
            processOrderItems(order.getItems());
            if (order.getTotalPrice() > 1000) {
                applyBonus(order);
            }
            order.setTotalPrice(calculateTotalPrice(order.getItems()));
            sendOrderConfirmationEmail(order);
        }
    }

    private void processOrderItems(List<Item> items) {
        // ...
    }

    private double calculateTotalPrice(List<Item> items) {
        // ...
    }
    // ... [其他方法保持不变]
}

### 2.2.2 提取类重构

当一个类承担了太多的职责时，可以使用提取类重构来改善设计。

#### 重构步骤

- 找出类中相关的数据和方法。
- 创建一个新的类，并将这些数据和方法移动到新类中。
- 更新原类，使其使用新类。
- 进行测试以确保重构后的行为与之前一致。

#### 示例代码

public class Order {
    // ...
}

public class OrderTotals {
    private Order order;
    public OrderTotals(Order order) {
        this.order = order;
    }
    public double getTotalPrice() {
        // ...
    }
    public boolean isAboveThreshold() {
        // ...
    }
}

public class OrderService {
    public void processOrder(Order order) {
        OrderTotals totals = new OrderTotals(order);
        if (totals.isAboveThreshold()) {
            // ...
        }
    }
}

### 2.2.3 用策略模式替换条件判断

当系统中存在大量基于条件的逻辑判断时，使用策略模式可以将每种情况的处理逻辑封装成独立的类。

#### 重构步骤

- 识别出所有的条件逻辑。
- 创建一个策略接口和一组实现了该接口的策略类。
- 替换原有的条件逻辑，使用策略对象来执行相应的行为。

#### 示例代码

public interface OrderStrategy {
    void process(Order order);
}

public class NormalOrderStrategy implements OrderStrategy {
    public void process(Order order) {
        // 处理普通订单
    }
}

public class BonusOrderStrategy implements OrderStrategy {
    public void process(Order order) {
        // 处理奖励订单
    }
}

public class OrderService {
    private Or