在 Java 中，重构（Refactoring）方法是指对现有代码进行修改，以改进其结构、可读性和可维护性，而不改变其功能。下面是一些常见的 Java 方法重构技术，帮助你提高代码质量：

1. 提炼方法（Extract Method）

如果一个方法过长，或者包含多个职责，可以将其中一部分代码提取到一个新的方法中。

重构前：

public void printStatement() {
    System.out.println("Customer Statement");
    System.out.println("Name: " + customer.getName());
    System.out.println("Balance: " + customer.getBalance());
    System.out.println("Transactions: ");
    for (Transaction transaction : customer.getTransactions()) {
        System.out.println(transaction.getDetails());
    }
}

重构后：

public void printStatement() {
    printHeader();
    printTransactions();
}

private void printHeader() {
    System.out.println("Customer Statement");
    System.out.println("Name: " + customer.getName());
    System.out.println("Balance: " + customer.getBalance());
}

private void printTransactions() {
    System.out.println("Transactions: ");
    for (Transaction transaction : customer.getTransactions()) {
        System.out.println(transaction.getDetails());
    }
}

---

2. 内联方法（Inline Method）

当一个方法只调用另一个方法，并且没有添加足够的价值时，可以考虑将其合并。

重构前：

public void printStatement() {
    printHeader();
}

private void printHeader() {
    System.out.println("Customer Statement");
}

重构后：

public void printStatement() {
    System.out.println("Customer Statement");
}

---

3. 替换临时变量（Replace Temp with Query）

如果一个临时变量在方法中被使用多次，且这个值不会发生变化，可以直接用其表达式替代。

重构前：

public double getTotalCost(Order order) {
    double basePrice = order.getBasePrice();
    double discount = order.getDiscount();
    return basePrice - discount;
}

重构后：

public double getTotalCost(Order order) {
    return order.getBasePrice() - order.getDiscount();
}

---

4. 引入解释性变量（Introduce Explaining Variable）

如果表达式过于复杂，可以用一个有意义的变量名来提取表达式，使代码更容易理解。

重构前：

if (a > b * 2 && c < d / 3) {
    // Do something
}

重构后：

boolean isComplexConditionMet = (a > b * 2) && (c < d / 3);
if (isComplexConditionMet) {
    // Do something
}

---

5. 替换魔法数字（Replace Magic Number with Constant）

将代码中使用的数字替换为具名常量，以提高可读性。

重构前：

public double calculateDiscount(double price) {
    if (price > 1000) {
        return price * 0.1;
    } else {
        return price * 0.05;
    }
}

重构后：

private static final double HIGH_PRICE_THRESHOLD = 1000;
private static final double HIGH_DISCOUNT = 0.1;
private static final double LOW_DISCOUNT = 0.05;

public double calculateDiscount(double price) {
    if (price > HIGH_PRICE_THRESHOLD) {
        return price * HIGH_DISCOUNT;
    } else {
        return price * LOW_DISCOUNT;
    }
}

---

6. 参数对象化（Introduce Parameter Object）

如果一个方法有多个参数，并且这些参数通常一起出现，可以将它们包装到一个对象中，从而简化方法签名。

重构前：

public void processOrder(int customerId, String product, int quantity, double price) {
    // Process the order
}

重构后：

public class Order {
    private int customerId;
    private String product;
    private int quantity;
    private double price;

    // Constructor, getters, setters
}

public void processOrder(Order order) {
    // Process the order
}

---

7. 移动方法（Move Method）

如果方法和它所在的类关系不大，可以考虑将该方法移到更相关的类中。

重构前：

public class Order {
    private Customer customer;

    public void processOrder() {
        // process order for the customer
    }
}

重构后：

public class Customer {
    public void processOrder(Order order) {
        // process order for the customer
    }
}

---

8. 简化条件表达式（Simplify Conditional Expressions）

通过简化 if 语句或使用 return 提前退出，可以使代码更简洁。

重构前：

public void calculate(int value) {
    if (value > 0) {
        doSomething();
    } else {
        doSomethingElse();
    }
}

重构后：

public void calculate(int value) {
    if (value > 0) {
        doSomething();
        return;
    }
    doSomethingElse();
}

---

9. 使用多态（Replace Conditional with Polymorphism）

当方法中有大量的 if 或 switch 语句时，可以通过引入多态来重构。

重构前：

public double calculateDiscount(Customer customer) {
    if (customer.getType() == CustomerType.VIP) {
        return 0.2;
    } else if (customer.getType() == CustomerType.REGULAR) {
        return 0.1;
    } else {
        return 0.05;
    }
}

重构后：

public interface DiscountStrategy {
    double calculateDiscount(Customer customer);
}

public class VIPDiscount implements DiscountStrategy {
    public double calculateDiscount(Customer customer) {
        return 0.2;
    }
}

public class RegularDiscount implements DiscountStrategy {
    public double calculateDiscount(Customer customer) {
        return 0.1;
    }
}

public class DefaultDiscount implements DiscountStrategy {
    public double calculateDiscount(Customer customer) {
        return 0.05;
    }
}

public class Customer {
    private DiscountStrategy discountStrategy;

    public double getDiscount() {
        return discountStrategy.calculateDiscount(this);
    }
}

---

总结

方法重构是为了使代码更简洁、可读性更强、易于维护。通过提炼、内联、简化条件和利用多态等方法，可以有效地提升代码质量。在进行重构时，要确保方法功能不发生变化，同时加强代码的表达能力。更多详细内容请关注其他相关文章。