代码重构｜代码的坏味道及其重构建议

于 2024-08-08 23:32:51 发布
阅读量302 收藏 5
点赞数 4
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44435110/article/details/141024923
版权

文章目录

概述

在软件开发过程中，随着项目规模的增长，代码中可能会出现一些不良的编程习惯，这些习惯被称为“代码的坏味道”。识别并消除这些坏味道是重构过程的重要组成部分。本文档将详细介绍几种常见的代码坏味道，并提供具体的重构建议。

1. 重复代码 (Duplicate Code)

描述: 当相同的代码片段出现在多个地方时，这通常意味着代码需要被提取成单独的方法或模块。

例子:

public class ShoppingCart {

    public void calculateTotalPrice(List<Item> items) {
        double total = 0;
        for (Item item : items) {
            total += item.getPrice();
        }
        System.out.println("Total price: " + total);
    }

    public void calculateShippingCost(List<Item> items, double shippingRate) {
        double totalWeight = 0;
        for (Item item : items) {
            totalWeight += item.getWeight();
        }
        double shippingCost = totalWeight * shippingRate;
        System.out.println("Shipping cost: " + shippingCost);
    }
}

重构建议:

public class ShoppingCart {

    private double sumOfItems(List<Item> items, Function<Item, Double> sumFunction) {
        double total = 0;
        for (Item item : items) {
            total += sumFunction.apply(item);
        }
        return total;
    }

    public void calculateTotalPrice(List<Item> items) {
        double total = sumOfItems(items, Item::getPrice);
        System.out.println("Total price: " + total);
    }

    public void calculateShippingCost(List<Item> items, double shippingRate) {
        double totalWeight = sumOfItems(items, Item::getWeight);
        double shippingCost = totalWeight * shippingRate;
        System.out.println("Shipping cost: " + shippingCost);
    }
}
2. 冗长的方法 (Long Method)

描述: 如果一个方法执行了太多的操作或者代码过长，这可能意味着它应该被分解成更小的部分。

例子:

public class ReportGenerator {

    public void generateReport(Employee employee) {
        System.out.println("Employee Report:");
        System.out.println("----------------");
        System.out.println("Name: " + employee.getName());
        System.out.println("ID: " + employee.getId());
        System.out.println("Department: " + employee.getDepartment());
        System.out.println("Position: " + employee.getPosition());
        System.out.println("Salary: " + employee.getSalary());
        System.out.println("Email: " + employee.getEmail());
        System.out.println("Phone: " + employee.getPhoneNumber());
        System.out.println("Address: " + employee.getAddress());
        System.out.println("Joining Date: " + employee.getJoiningDate());
    }
}

重构建议:

public class ReportGenerator {

    public void generateReport(Employee employee) {
        printEmployeeDetails(employee);
    }

    private void printEmployeeDetails(Employee employee) {
        System.out.println("Employee Report:");
        System.out.println("----------------");
        printLine("Name", employee.getName());
        printLine("ID", employee.getId());
        printLine("Department", employee.getDepartment());
        printLine("Position", employee.getPosition());
        printLine("Salary", employee.getSalary());
        printLine("Email", employee.getEmail());
        printLine("Phone", employee.getPhoneNumber());
        printLine("Address", employee.getAddress());
        printLine("Joining Date", employee.getJoiningDate());
    }

    private void printLine(String label, String value) {
        System.out.println(label + ": " + value);
    }

    private void printLine(String label, int value) {
        System.out.println(label + ": " + value);
    }

    private void printLine(String label, double value) {
        System.out.println(label + ": " + value);
    }

    private void printLine(String label, Date value) {
        System.out.println(label + ": " + value);
    }
}
3. 过多的参数 (Too Many Arguments)

描述: 如果一个方法接收了过多的参数，这可能意味着参数列表需要被精简或替换为一个更复杂的对象。

例子:

public class OrderProcessor {

    public void processOrder(String orderId, String customerName, String product, int quantity, double price, String address, String paymentMethod) {
        // 处理订单逻辑
    }
}

重构建议:

public class OrderProcessor {

    public void processOrder(Order order) {
        // 处理订单逻辑
    }
}

public class Order {

    private final String orderId;
    private final Customer customer;
    private final Product product;

    public Order(String orderId, Customer customer, Product product) {
        this.orderId = orderId;
        this.customer = customer;
        this.product = product;
    }

    // Getters and other methods...

    public String getOrderId() {
        return orderId;
    }

    public Customer getCustomer() {
        return customer;
    }

    public Product getProduct() {
        return product;
    }
}

public class Customer {

    private final String name;
    private final Address address;
    private final String paymentMethod;

    public Customer(String name, Address address, String paymentMethod) {
        this.name = name;
        this.address = address;
        this.paymentMethod = paymentMethod;
    }

    // Getters and other methods...

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public String getPaymentMethod() {
        return paymentMethod;
    }
}

public class Product {

    private final String productName;
    private final int quantity;
    private final double price;

    public Product(String productName, int quantity, double price) {
        this.productName = productName;
        this.quantity = quantity;
        this.price = price;
    }

    // Getters and other methods...

    public String getProductName() {
        return productName;
    }

    public int getQuantity() {
        return quantity;
    }

    public double getPrice() {
        return price;
    }
}

public class Address {

    private final String street;
    private final String city;
    private final String zipCode;

    public Address(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }

    // Getters and other methods...

    public String getStreet() {
        return street;
    }

    public String getCity() {
        return city;
    }

    public String getZipCode() {
        return zipCode;
    }
}
4. 散乱的变动 (Scattered Changes)

描述: 当相关的变更分散在多个地方时，这表明代码需要更好的组织。

例子:

public class UserManagement {

    public void updateUser(User user) {
        // 更新用户信息
        user.setName("New Name");
        user.setEmail("new.email@example.com");
        // 更改密码
        user.setPassword("newPassword123");
    }

    public void resetUser(User user) {
        // 重置用户信息
        user.setName("Default Name");
        user.setEmail("default.email@example.com");
        // 更改密码
        user.setPassword("defaultPassword123");
    }
}

重构建议:

public class UserManagement {

    public void updateUser(User user, String name, String email, String password) {
        user.setName(name);
        user.setEmail(email);
        user.setPassword(password);
    }

    public void resetUser(User user) {
        updateUser(user, "Default Name", "default.email@example.com", "defaultPassword123");
    }
}
5. 冗余注释 (Redundant Comments)

描述: 当注释重复了代码本身的功能说明时，这样的注释是没有必要的。

例子:

public class Calculator {

    /**
     * This method adds two numbers.
     * @param a the first number
     * @param b the second number
     * @return the sum of a and b
     */
    public int add(int a, int b) {
        // Add the two numbers
        return a + b;
    }
}

重构建议:

public class Calculator {

    /**
     * Adds two numbers.
     *
     * @param a the first number
     * @param b the second number
     * @return the sum of a and b
     */
    public int add(int a, int b) {
        return a + b;
    }
}
6. 复杂的条件语句 (Complex Conditional Logic)

描述: 如果条件语句过于复杂，这可能意味着需要简化逻辑。

例子:

public class DiscountCalculator {

    public double applyDiscount(Order order) {
        double discount = 0;
        if (order.getTotalAmount() > 100 && order.getTotalAmount() <= 200) {
            discount = 10; // 10% off
        } else if (order.getTotalAmount() > 200 && order.getTotalAmount() <= 500) {
            discount = 20; // 20% off
        } else if (order.getTotalAmount() > 500) {
            discount = 30; // 30% off
        }
        return order.getTotalAmount() - (order.getTotalAmount() * (discount / 100));
    }
}

重构建议:

public class DiscountCalculator {

    private static final Map<Integer, Integer> DISCOUNTS = Map.of(
        100, 10,
        200, 20,
        500, 30
    );

    public double applyDiscount(Order order) {
        double discount = 0;
        int totalAmount = order.getTotalAmount();

        DISCOUNTS.forEach((threshold, rate) -> {
            if (totalAmount > threshold) {
                discount = rate;
            }
        });

        return order.getTotalAmount() - (order.getTotalAmount() * (discount / 100.0));
    }
}
7. 过大的类 (Large Class)

描述: 如果一个类承担了过多的责任，这通常意味着类需要被分割成更小的、职责更单一的类。

例子:

public class EmployeeManager {

    public void createEmployee(String name, String email, String department) {
        // 创建员工
    }

    public void updateEmployee(Employee employee, String newName, String newEmail, String newDepartment) {
        // 更新员工信息
    }

    public void deleteEmployee(Employee employee) {
        // 删除员工
    }

    public void listEmployees() {
        // 列出所有员工
    }

    public void sendEmail(Employee employee, String subject, String message) {
        // 发送邮件给员工
    }
}

重构建议:

public class EmployeeManager {

    private final EmployeeRepository repository;
    private final EmailService emailService;

    public EmployeeManager(EmployeeRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }

    public void createEmployee(String name, String email, String department) {
        // 创建员工
        Employee employee = new Employee(name, email, department);
        repository.save(employee);
    }

    public void updateEmployee(Employee employee, String newName, String newEmail, String newDepartment) {
        // 更新员工信息
        employee.setName(newName);
        employee.setEmail(newEmail);
        employee.setDepartment(newDepartment);
        repository.update(employee);
    }

    public void deleteEmployee(Employee employee) {
        // 删除员工
        repository.delete(employee);
    }

    public List<Employee> listEmployees() {
        // 列出所有员工
        return repository.findAll();
    }

    public void sendEmail(Employee employee, String subject, String message) {
        // 发送邮件给员工
        emailService.sendEmail(employee.getEmail(), subject, message);
    }
}

public interface EmployeeRepository {
    void save(Employee employee);
    void update(Employee employee);
    void delete(Employee employee);
    List<Employee> findAll();
}

public interface EmailService {
    void sendEmail(String to, String subject, String message);
}
结论

通过识别和消除代码中的“坏味道”，我们可以显著提高代码的质量、可读性和可维护性。重构是软件开发过程中不可或缺的一部分，它有助于确保代码随着时间的推移仍然易于理解和修改。上述示例提供了一些基本的指导原则，但在实际应用中可能还需要根据具体情况做出适当的调整。

进击的小白菜
关注
专栏目录
代码的坏味道——《重构——改善既有代码的设计》
tianzhiyi1989sq的博客
02-08 230
1. Duplicated Code 重复代码，在程序中多次出现的相同结构或功能的代码 同一个类中的两个函数含有相同的表达式 两个互为兄弟的子类中含相同的表达式 相互独立的类中出现相同表达式 2. Long Method 过长的函数难以理解及维护 段函数或间接层具有很强的解释能力、共享能力和选择能力 面向对象几乎完全免除了进程内函数调用的开销 短函数功能单一明确，可以起一个比较贴近功能的名称...
代码中坏味道和对应重构方法——摘自《重构，改善既有代码的设计》
Water的技术博客
11-18 3538
坏味道1 ： 重复代码 重用重构： 1. Extract Method （提炼函数），                       2.  Extract Class （提炼类），                       3.  Pull Up Method （函数上移）：有些函数， 在各个子类中产生完全相同的结果。 将该函数移至超类。                      4.
重构-改善既有代码的设计：坏代码的味道，编写代码20多宗罪（三）
黄规速博客:学如逆水行舟，不进则退
05-24 8087
坏代码的味道，代码编写的22宗罪，主要分为四大类：对象函数，对象数据，对象关系、其他问题等。
代码的坏味道 重构方式对应表
03-16
代码的坏味道 重构方式对应表 DOC 可打印.
谈谈代码重构
热门推荐
明月清风
05-10 4万+
开发人员可能听到过"bad smell"这个词，这个词用在软件编码中是什么意思呢？ 代码还有smell吗？当然没有，正如计算机病毒，bug等词一样，这只是个形象的说法。这个词在这里的意思是代码实现了需求，但是代码却不精炼，冗余，结构混乱，难读懂，难维护，难扩展等等。与之相对应的一个词是"refactor"，即代码重构。我们在看些外国人写的程序时可以发现，他们的代码里一般会定义大量的类、接口、方法，
代码重构
qq_41044525的博客
07-30 97
cheatsheet promoterx maven hepler sonarQube 1、使用卫语句化嵌套条件 修改前： 修改后 ：圈复杂度减少一层，先判断不合法的，再走合法流程 2.消除掉过长参数列表 修改前 修改后： idea> refactor> Extract>Parameter Object 3. ...
《重构改善既有代码的设计第2版》第1章 重构，第一个示例重构过程
最新发布
03-26
1. 识别代码坏味道及其影响。 2. 使用重构技术改进代码结构。 3. Git的使用，包括提交、查看历史和版本回退。 4. 单元测试在重构中的角色及编写测试用例的方法。 5. 如何利用IDE和插件进行有效的重构。 6. 实践重构...
重构代码笔记1
08-04
本文以"重构代码笔记1"为出发点，深入探讨了24种常见的代码坏味道及其对应的重构策略。 首先，神秘命名（Mysterious Name）是重构的常见起点，通过改变函数声明和变量名，使其更具描述性，如将`cash0`更改为`cash_...
重构-改善既有代码的设计.pdf
05-25
重构有助于消除代码中的坏味道（如重复代码、冗余逻辑等），从而使代码更加简洁高效。 #### 2. 增强可维护性 重构后的代码更容易被理解和修改，这对于未来的维护工作来说非常重要。 #### 3. 改进设计 重构可以帮助...
编写c语言程序:定义员工结构体(员工信息有员工号，员工姓名，部门)。定义一个结构体变量，并使用结构体指针变量对结构体变量赋值，并写入到文件C:\employer.txt文件中。 2.在程序1的基础上，编写函数模块从C:\employer.txt中读取数据并打印输出到屏幕上。
03-22
答案： 1. 以下是编写的C语言程序： ``` #include <stdio.h> #include <stdlib.h> struct Employee { int empNo; char empName[50]; char department[50]; }; int main() { struct Employee emp; struct Employee *empPtr = &emp; printf("Enter employee number: "); scanf("%d", &emp.empNo); printf("Enter employee name: "); scanf("%s", emp.empName); printf("Enter department: "); scanf("%s", emp.department); FILE *fp; fp = fopen("C:\\employer.txt", "w"); if (fp == NULL) { printf("Error opening file\n"); exit(1); } fprintf(fp, "%d %s %s\n", empPtr->empNo, empPtr->empName, empPtr->department); fclose(fp); printf("Employee details written to file successfully.\n"); return 0; } ``` 2. 以下是从C:\employer.txt中读取数据并打印输出到屏幕上的函数模块： ``` #include <stdio.h> #include <stdlib.h> struct Employee { int empNo; char empName[50]; char department[50]; }; void printEmployeeDetails() { struct Employee emp; struct Employee *empPtr = &emp; FILE *fp; fp = fopen("C:\\employer.txt", "r"); if (fp == NULL) { printf("Error opening file\n"); exit(1); } fscanf(fp, "%d %s %s", &empPtr->empNo, empPtr->empName, empPtr->department); printf("Employee Number: %d\n", empPtr->empNo); printf("Employee Name: %s\n", empPtr->empName); printf("Department: %s\n", empPtr->department); fclose(fp); } int main() { printEmployeeDetails(); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的小白菜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值