最后用一个流程式的函数调用

为了实现重构，我们需要根据以下步骤将代码功能分离，使每个函数的功能单一，便于逻辑清晰地调用。以下是一个示例，展示如何把一个复杂的函数拆分成多个功能单一的函数，最后通过流程式的函数调用来组织整个程序的执行。

重构步骤：

1. 分析代码的不同功能：确定每一部分代码的具体职责。
2. 函数拆分：将每个功能单独拆分为函数，每个函数只做一件事。
3. 流程式调用：最后编写一个主流程函数，将所有步骤按顺序调用。

示例：原始代码

假设我们有一段代码，用来处理用户的订单并计算总价：

public class OrderProcessor {
    public void processOrder(String userId, String productId, String discountCode) {
        // 1. 验证用户
        User user = Database.getUserById(userId);
        if (user == null) {
            throw new IllegalArgumentException("用户不存在");
        }

        // 2. 查找产品
        Product product = Database.getProductById(productId);
        if (product == null) {
            throw new IllegalArgumentException("产品不存在");
        }

        // 3. 应用折扣
        double discount = 0.0;
        if (discountCode != null && !discountCode.isEmpty()) {
            Discount discountObj = Database.getDiscountByCode(discountCode);
            if (discountObj != null) {
                discount = discountObj.getDiscountAmount();
            }
        }

        // 4. 计算总价
        double finalPrice = product.getPrice() - discount;

        // 5. 保存订单
        Order order = new Order(user, product, finalPrice);
        Database.saveOrder(order);
    }
}

重构后的代码

1. 将功能单独拆分成函数

public class OrderProcessor {
    
    // 1. 验证用户
    private User validateUser(String userId) {
        User user = Database.getUserById(userId);
        if (user == null) {
            throw new IllegalArgumentException("用户不存在");
        }
        return user;
    }

    // 2. 查找产品
    private Product findProduct(String productId) {
        Product product = Database.getProductById(productId);
        if (product == null) {
            throw new IllegalArgumentException("产品不存在");
        }
        return product;
    }

    // 3. 计算折扣
    private double applyDiscount(String discountCode) {
        double discount = 0.0;
        if (discountCode != null && !discountCode.isEmpty()) {
            Discount discountObj = Database.getDiscountByCode(discountCode);
            if (discountObj != null) {
                discount = discountObj.getDiscountAmount();
            }
        }
        return discount;
    }

    // 4. 计算总价
    private double calculateTotalPrice(Product product, double discount) {
        return product.getPrice() - discount;
    }

    // 5. 保存订单
    private void saveOrder(User user, Product product, double finalPrice) {
        Order order = new Order(user, product, finalPrice);
        Database.saveOrder(order);
    }

    // 主函数 - 按顺序调用各个步骤
    public void processOrder(String userId, String productId, String discountCode) {
        User user = validateUser(userId);
        Product product = findProduct(productId);
        double discount = applyDiscount(discountCode);
        double finalPrice = calculateTotalPrice(product, discount);
        saveOrder(user, product, finalPrice);
    }
}

解释：

1. validateUser：负责用户验证。
2. findProduct：负责查找产品。
3. applyDiscount：负责计算折扣。
4. calculateTotalPrice：负责计算订单的最终价格。
5. saveOrder：负责保存订单。

重构后的好处：

• 每个函数功能单一，便于理解和维护。
• 清晰的流程：processOrder 函数变得非常简洁，体现了订单处理的逻辑顺序。
• 易扩展：未来如果要添加新的功能，可以很容易地在相应步骤中扩展或替换逻辑，而不影响其他部分。

通过这样的重构，你的代码将变得更加模块化、清晰易读。