Java代码重构学习笔记-在对象之间搬移特性

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量659 收藏
点赞数
文章标签： java 重构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/logan_addoil/article/details/130262611
版权

Move Method（搬移函数）

它的目的是将一个方法从原始类中搬移到其他类中，从而使类的职责更加清晰明确。

举个例子，假设有一个名为 Customer 的类，其中包含了一个用于计算客户折扣的方法 applyDiscount：

public class Customer {
    private String name;
    private int discount;
    
    public void applyDiscount(double amount) {
        amount *= (1 - discount / 100.0);
        System.out.println(name + " applied a discount of " + discount + "%, the final amount is " + amount);
    }
    
    // getter and setter methods for name and discount
}

在这段代码中，applyDiscount 方法用于计算客户的折扣，并在控制台上输出折扣信息。然而，applyDiscount 方法并没有直接与 Customer 类的数据进行交互，因此可以考虑使用 Move Method 进行重构，将该方法搬移到一个新的 DiscountCalculator 类中，比如：

public class Customer {
    private String name;
    private int discount;
    
    // getter and setter methods for name and discount
    
    public String getName() {
        return name;
    }
    
    public int getDiscount() {
        return discount;
    }
}

public class DiscountCalculator {
    public void applyDiscount(Customer customer, double amount) {
        int discount = customer.getDiscount();
        amount *= (1 - discount / 100.0);
        System.out.println(customer.getName() + " applied a discount of " + discount + "%, the final amount is " + amount);
    }
}

通过 Move Method 重构后，applyDiscount 方法被搬移到了 DiscountCalculator 类中，从而使 Customer 类的职责更加明确，只负责处理与客户信息相关的数据和操作。DiscountCalculator 类则专门用于计算折扣，使得各自的职责更加清晰明确。

需要注意的是，在进行 Move Method 重构时，需要确保新类具有明确的职责，并且确保搬移方法的逻辑正确性和稳定性。同时还需要考虑搬移方法可能涉及到的依赖关系、访问权限和继承关系等，确保程序的整体结构和功能不会发生变化。

Move Field（搬移字段）

它的目的是将一个字段（属性）从一个类中搬移到另一个相关的类中，从而使类的职责更加清晰明确。

举个例子，假设有一个名为 Employee 的类，其中包含了员工的基本信息和员工部门信息，如下所示：

public class Employee {
    private String name;
    private int age;
    private String department;
    
    // setter and getter methods for name, age, department
}

在这段代码中，Employee 类包含了员工名字、年龄和所在部门等信息。然而，随着业务规模扩大，可能需要对员工信息和部门信息进行更加细粒度的管理，因此可以考虑使用 Move Field 进行重构，将 department 字段搬移到一个新的 Department 类中，如下所示：

public class Employee {
    private String name;
    private int age;
    private Department department;

    // getter and setter methods for name, age, department
}

public class Department {
    private String name;

    // getter and setter methods for name
}

通过 Move Field 重构后，Employee 类将员工部门信息委托给一个新的 Department 类来管理，从而使得两个类各司其职，相互独立。在后续对员工和部门信息进行操作时，可以更加方便地控制和管理。

需要注意的是，在进行 Move Field 重构时，要确保新类具有明确的职责，并且需要确保搬移字段的逻辑正确性和稳定性。同时，还需要考虑数据访问权限、继承关系以及可能涉及到的依赖关系等因素，确保程序的整体结构和功能不会发生变化，同时提高代码的可读性和可维护性。

Extract Class（提炼类）

它的目的是将一个类中的一部分职责提取出来，组成一个新的类。这样可以将职责分离，降低类的复杂度，提高代码的可读性和可维护性。

举个例子，假设有一个名为 Person 的类，其中包含了人的基本信息、地址信息和联系方式，如下所示：

public class Person {
    private String name;
    private int age;
    private String street;
    private String city;
    private String zipCode;
    private String phone;
    private String email;
    
    // getter and setter methods for name, age, street, city, zipCode, phone, email
}

在这段代码中，Person 类包含了人的各种信息，然而这些信息并没有很好地进行划分和组织。如果需要对地址信息进行更加详细的管理，可以考虑使用 Extract Class 进行重构，将地址信息以及相关操作提取为一个新的 Address 类。

public class Person {
    private String name;
    private int age;
    private Address address;
    private String phone;
    private String email;
    
    // getter and setter methods for name, age, address, phone, email
}

public class Address {
    private String street;
    private String city;
    private String zipCode;

    // getter and setter methods for street, city, zipCode
}

通过 Extract Class 重构后，Person 类职责更加明确，只负责处理人的基本信息和联系方式，Address 类则专门用于管理地址信息，使得代码更加清晰易懂。在后续修改和扩展时，可以分别对两个类进行操作，减少了代码重复和耦合。

需要注意的是，在进行 Extract Class 重构时，要确保新类具有明确的职责，并且要确保拆分出来的类能够独立完成相应的操作。同时，要考虑数据访问权限、继承关系以及可能涉及到的依赖关系等因素，确保程序的整体结构和功能不会发生变化，同时提高代码的可读性和可维护性。

Inline Class（将类内联化）

它的目的是消除过度抽象的中间层，将一个只有少量属性和方法的类直接合并到另一个类中，从而简化程序的结构。

举个例子，假设有一个名为 Customer 的类，其中只包含了一个名字属性和一个地址属性，如下所示：

public class Customer {
    private String name;
    private Address address;
    
    // getter and setter methods for name, address
}

public class Address {
    private String street;
    private String city;
    private String zipCode;
    
    // getter and setter methods for street, city, zipCode
}

在这段代码中，Customer 类只包含了一个名字属性和一个地址属性，而 Address 类则包含了具体的地址信息。如果 Customer 类只在程序的某个非常狭窄的范围内使用，并且不涉及到地址信息的处理，可以考虑使用 Inline Class 进行重构，将 Customer 类中的属性和方法直接合并到另一个类中。

public class Order {
    private String customerName;
    private String street;
    private String city;
    private String zipCode;
    
    // getter and setter methods for customerName, street, city, zipCode
}

通过 Inline Class 重构后，Customer 类被完全内联到 Order 类中，简化了程序的结构，同时也提高了代码的可读性和可维护性。在后续修改和扩展时，只需要对 Order 类进行操作即可。

需要注意的是，在进行 Inline Class 重构时，要确保被内联的类只有少量的属性和方法，并且没有其他用途。同时，也要考虑程序的继承关系、依赖关系等因素，确保程序的整体结构和功能不会发生变化，同时提高代码的可读性和可维护性。

Hide Delegate（隐藏“委托关系”）

它的目的是减少类之间的耦合程度，将一个类对另一个类的调用关系隐藏起来，从而简化程序的结构。

举个例子，假设有一个名为 Department 的类，其中包含了员工管理的相关信息，如下所示：

public class Department {
    private String name;
    private List<Employee> employees;
    
    // getter and setter methods for name, employees
    
    public Employee getManager() {
        return employees.get(0);
    }
}

在这段代码中，Department 类中包含了一个名字属性和一个员工列表属性，同时定义了一个 getManager() 方法，该方法返回员工列表中的第一个元素，即部门经理。这里存在一个明显的委托关系，即 Department 类委托给 Employee 类来处理部门经理的获取操作。

如果在程序中需要频繁地获取部门经理信息，并且考虑到后续可能会更改获取逻辑，也许应当采用 Hide Delegate 进行重构，将 Department 类中的委托关系隐藏起来，使得其他类不需要直接依赖于 Employee 类。

public class Department {
    private String name;
    private List<Employee> employees;
    
    // getter and setter methods for name, employees
    
    public Employee getManager() {
        return new Manager(employees.get(0));
    }
}

public class Manager {
    private Employee employee;
    
    public Manager(Employee employee) {
        this.employee = employee;
    }
    
    public String getName() {
        return employee.getName();
    }
    
    // other methods related to manager
}

通过 Hide Delegate 重构后，Department 类中的委托关系被隐藏到一个新的 Manager 类中，其他类可以通过 Department 类提供的接口间接获取部门经理信息，而不需要直接依赖于 Employee 类。在后续修改和扩展时，也能够更加方便地进行维护和扩展。

需要注意的是，在进行 Hide Delegate 重构时，要确保隐藏的委托关系能够被其他类所使用，并且不会影响代码的原有功能。同时也要考虑程序的依赖关系、继承关系和设计初衷等因素，确保程序的整体结构和功能不会发生变化，并提高代码的可读性和可维护性。

Remove Middle Man（移除中间人）

它的目的是消除过度抽象的中间层，简化程序的结构，减少不必要的委托关系。

举个例子，假设有一个名为 Person 的类，其中包含了姓名、联系方式等个人信息，同时定义了一个 getPhoneNumber() 方法来获取个人的电话号码，如下所示：

public class Person {
    private String name;
    private String phoneNumber;
    private String email;
    
    // getter and setter methods for name, phoneNumber, email
    
    public String getPhoneNumber() {
        return phoneNumber;
    }
}

在这段代码中，Person 类包含了个人信息的属性和一个用于获取电话号码的方法。假设现在需要获取与该 person 关联的 company 的电话号码，可以通过在 Person 类中添加一个 getCompanyPhoneNumber() 方法实现：

public class Person {
    private String name;
    private String phoneNumber;
    private String email;
    private Company company;
    
    // getter and setter methods for name, phoneNumber, email
    
    public String getPhoneNumber() {
        return phoneNumber;
    }
    
    public String getCompanyPhoneNumber() {
        if (company != null) {
            return company.getPhoneNumber(); // 委托给 Company 对象进行处理
        } else {
            return null;
        }
    }
}

public class Company {
    private String name;
    private String phoneNumber;
    
    // getter and setter methods for name, phoneNumber
}

在这段代码中，Person 类中增加了一个 getCompanyPhoneNumber() 方法，该方法将获取公司电话号码的操作委托给了另一个 Company 类，通过中间的 company 对象来间接获取公司电话号码。

如果考虑到代码的可读性和可维护性，也许可以采用 Remove Middle Man 进行重构，去除不必要的中间层，直接在客户端调用 Company 类中的 getPhoneNumber() 方法。

public class Person {
    private String name;
    private String phoneNumber;
    private String email;
    private Company company;
    
    // getter and setter methods for name, phoneNumber, email
    
    public String getPhoneNumber() {
        return phoneNumber;
    }
    
    public Company getCompany() {
        return company;
    }
}

public class Company {
    private String name;
    private String phoneNumber;
    
    // getter and setter methods for name, phoneNumber
}

// client code
Person person = new Person();
Company company = person.getCompany();
String companyPhoneNumber = company != null ? company.getPhoneNumber() : null;

通过 Remove Middle Man 重构后，Person 类中不再包含 getCompanyPhoneNumber() 方法，而是直接返回 company 对象，在客户端可以直接调用 Company 类中的 getPhoneNumber() 方法，从而消除了过度的中间层，简化了程序的结构，提高了代码的可读性和可维护性。

需要注意的是，在进行 Remove Middle Man 重构时，要确保移除中间层不会影响原有的功能，并且能够提高代码的可读性和可维护性。同时也要考虑程序的依赖关系、继承关系和设计初衷等因素，确保程序的整体结构和功能不会发生变化。

Introduce Foreign Method（引入外加函数）

它的主要目的是在无法修改现有代码的情况下，向对象中添加一个新的方法（即所谓的“外来函数”），以完成特定的操作。

举个例子，假设有一个名为 DateUtil 的工具类，其中包含了一些可以方便地操作日期的静态方法，如下所示：

public class DateUtil {
    public static Date getNextWeekday(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        
        if (dayOfWeek == Calendar.FRIDAY) {
            calendar.add(Calendar.DATE, 3);
        } else if (dayOfWeek == Calendar.SATURDAY) {
            calendar.add(Calendar.DATE, 2);
        } else {
            calendar.add(Calendar.DATE, 1);
        }
        
        return calendar.getTime();
    }
}

在这段代码中，DateUtil 类包含了一个 getNextWeekday() 方法，用于获取下一个工作日的日期。如果需要在另一个类中频繁地使用 getNextWeekday() 方法， 可以考虑使用 Introduce Foreign Method 重构，向该类中添加一个外来函数，使得其他类可以直接调用该函数，而不需要再次访问 DateUtil 类。

public class SomeClass {
    private Date date;
    
    // getter and setter methods for date
    
    public Date getNextWeekday() {
        return DateUtil.getNextWeekday(date);
    }
}

通过 Introduce Foreign Method 重构后，SomeClass 类中添加了一个 getNextWeekday() 方法，该方法直接委托给 DateUtil 类中的 getNextWeekday() 方法进行处理，在客户端可以直接调用 SomeClass 类中的 getNextWeekday() 方法来获取下一个工作日的日期。

需要注意的是，使用 Introduce Foreign Method 重构时要确保该外来函数能够被其他类所使用，并且不会影响原有代码的行为和功能。同时也要考虑程序的依赖关系、继承关系和设计初衷等因素，确保程序的整体结构和功能不会发生变化。

Introduce Local Extension (引入本地扩展)

它的主要目的是在无法修改现有代码的情况下，向现有类中添加新的方法和属性，使其更加灵活和易用。

举个例子，假设有一个名为 Employee 的类，用于表示一个员工对象，该类包含了员工的姓名、工号、月薪等信息。现在需要为该类添加一个新的功能，即计算员工的年终奖金，假设计算公式为月薪的 1.5 倍。但由于不允许修改 Employee 类的源代码，因此不能直接在该类中添加一个计算年终奖金的方法。

这时可以考虑使用 Introduce Local Extension 重构，定义一个子类或者放置在同一个包下的新类，添加一个计算年终奖金的方法，将 Employee 对象作为该方法的参数进行计算。

public class Employee {
    private String name;
    private String id;
    private double monthlySalary;
    
    // getter and setter methods for name, id, monthlySalary
}

public class EmployeeExtension {
    private Employee employee;
    
    public EmployeeExtension(Employee employee) {
        this.employee = employee;
    }
    
    public double getYearEndBonus() {
        return employee.getMonthlySalary() * 1.5;
    }
}

在上述代码中，定义了一个名为 EmployeeExtension 的类，该类包含了一个指向 Employee 对象的引用，同时添加了一个计算年终奖金的方法 getYearEndBonus()。客户端可以通过创建 EmployeeExtension 对象，将 Employee 对象作为参数传入该对象进行操作。

Employee employee = new Employee();
// set employee's name, id, monthlySalary
EmployeeExtension extension = new EmployeeExtension(employee);
double bonus = extension.getYearEndBonus();

通过 Introduce Local Extension 重构后，成功添加了计算年终奖金的功能，同时也保留了原有 Employee 类的功能和行为。需要注意的是，在使用 Introduce Local Extension 重构时，要确保添加的新方法和属性能够满足需求，同时也要考虑程序的依赖关系和设计初衷等因素，确保程序的整体结构和功能不会发生变化。

Logan_addoil
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP 杂谈《重构-改善既有代码的设计》之二 对象之间搬移特性
01-20
思维导图 索引： Ø Move Method（搬移函数） Ø Move Field （搬移值域） Ø Extract Class （提炼类） ... 承接上文PHP 杂谈《重构-改善既有代码的设计》之 重新组织你的函数 ，继续说重构方面的内容。    专
阿里面试官：你在工作中是如何做代码重构的？
猿码天地
05-12 989
我是猿人，一个热爱技术、热爱编程的IT猿。技术是开源的，知识是共享的！写作是对自己学习的总结和记录，如果您对 Java、分布式、微服务、中间件、Spring Boot、Spring Clo...
java重构 代码迁移搬移_【Java重构系列】重构31式之搬移方法
weixin_28812983的博客
03-01 706
重构第二式：搬移方法 (Refactoring 2: Move Method)毋容置疑，搬移方法(Move Method)应该是最常用的重构手段之一，正因为太常用而且较为简单，以至于很多人并不认为它是一种很有价值的重构，但事实并非如此，在最初的代码诞生之后，有些方法可能会被放在一些不合适的地方，例如，一个方法被其他类使用比在它所在的类中的使用还要频繁或者一个方法本身就不应该放在某个类中时，我们应该...
《重构-改善既有代码的设计》重构手法(搬移特性)
SuperYang_的博客
12-11 848
文章内容和思路来自《重构-改善既有代码的设计》 1> 搬移函数：搬移函数最直接的一个动因就是频繁引用其他上下文的元素，而对自身上下文中的元素却关心甚少。此时，让它去与那些更亲密的元素相会，通常会取得更好的封装效果，因为系统别处就可以减少对当前模块的依赖 2> 搬移字段：如果更新一个字段需要同时在多个结构中做出修改，那也是一个征兆，表明该字段需要被搬移到一个集中的地方，这样每次只需修改一个地方 3> 搬移语句到函数：要维护代码库的健康发展，需要遵守几...
重构对象-Move Method搬移函数一
Bruce小鬼
03-17 464
当前类的函数与另外一个类有非常多的交流(调用关系)，那么两个类之间有太多合作而形成高度耦合（highly coupled)，我就会搬移函数。通过这种手段，我可以使系统中的classes更简单，这些classes最终也将更干净利落地实现系统交付的任务。
25种代码坏味道总结+优化示例
竹林幽深
03-02 731
https://mp.weixin.qq.com/s/Da8V0iu4jMgs5qv0jXNm2w
重构笔记——搬移函数
皮斯特劳沃
01-13 1万+
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/42679983         我们都知道，类往往因为承担过多的责任而变得臃肿不堪。这种情况下，一般会使用"提炼类"这种手法将一部分责任分离出去。如果一个类变得"不负责任"，一般会使用“内联类”这种手法将它融入另一个类。如果一个类使用了另一个类，一般会运用"隐藏委托关系"手法将这种关系隐藏起来通常是有帮助的。有时候隐藏委托关系会导致拥有者的接口经常性地变化，
重构改善既有代码设计--重构手法10：Move Method （搬移函数）
weixin_30698527的博客
09-16 570
你的程序中，有个函数与其所驻类之外的另一个类进行更多的交流：调用后者，或被后者调用。在该函数最常用引用的类中建立一个有着类似行为的新函数。将旧函数编程一个单纯的委托函数，或是将旧函数完全移除。 动机：“搬移函数”是重构理论的支柱。如果一个类有太多行为，或如果一个类与另一个类有太多合作而形成高度耦合，就需要搬移函数。通过这种手段，可以使系统中的类更简单，这些类最终也将更干净利落的实现...
如何重构代码-简单、灵活的实现对象复制
02-27
单个对象复制在初步的需求中有个很简单的业务，就是定义销售合同，并且合同中可以配置产品设备数据，如下：其中有个业务功能就是需要对已经存在的销售合同进行复制、剪贴和粘贴的工作。对于程序来说，它其实就需要...
深入理解Java虚拟机---学习感悟以及笔记
02-24
本文来自于cnblogs,为什么要学习Java虚拟机？它能干什么，文章从作者得角度带大家深入Java虚拟机相关内容，希望对大家有帮助。...还有以前的在理解重载和重构的时候只是在表面去理解，当我看完这本书明白，原
重构——10搬移函数（Move Method）
weixin_33774883的博客
12-03 4964
搬移函数（Move Method） 你的程序中，有个函数与其所驻类之外的另一个类进行更多的交流：调用后者，或者被后者调用。在该函数最常引用的类中建立一个有着类似行为的新函数。将就函数变成一个单纯的委托函数，或是将旧函数完全移除 一、动机 减少类之间的耦合，是系统中的类更简单，更干净利落的完成系统交付的任务 二、做法 1、检查源类中被原函数所使用的一切特性...
【Java重构系列】重构31式之搬移方法
热门推荐
刘伟技术博客
01-11 2万+
毋容置疑，搬移方法(Move Method)应该是最常用的重构手段之一，正因为太常用而且较为简单，以至于很多人并不认为它是一种很有价值的重构，但事实并非如此，在最初的代码诞生之后，有些方法可能会被放在一些不合适的地方，例如，一个方法被其他类使用比在它所在的类中的使用还要频繁或者一个方法本身就不应该放在某个类中时，我们应该考虑将它移到更合适的地方。搬移方法，顾名思义就是将方法搬移至合适的位置，如将方法搬移到更频繁地使用它的类中。
《重构2》第八章-搬移
乾复道
06-22 242
搬移是重构的一个基本准则
java move函数重新调用_Move Method (搬移函数)
weixin_34878397的博客
03-06 855
Summary:程序中，有个函数与其所驻类之外的另个一个函数进行更多的交流：调用后者，或者被后者调用。在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或是将旧函数完全移除。Motivation：“搬移函数”是重构理论的支柱。如果有一个类有太多行为，或如果一个类与另一个类有太多合作而形成高度耦合，就可以办以函数。通过这种手段，可以使系统中的类更简单，这些类最终也将...
jar包增量更新分析
junlaiyan的专栏
05-16 268
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 899
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 628
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 908
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 27
1，引入核心关键依赖。
java代码重构学习视频
06-09
以下是一些 Java 代码重构学习视频，供您参考： 1. 《重构：改善既有代码的设计》视频课程，由 Martin Fowler 和 Kent Beck 讲授，涵盖了重构的基本概念、常用的重构手法、应用重构的实际案例等方面的内容。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值