Java代码重构学习笔记-重新组织数据

Self Encapsulate Field (自封装字段)

它的主要目的是通过使用 getter 和 setter 方法来访问类的私有属性，以提高代码的可维护性和灵活性。

举个例子，假设有一个名为 Customer 的类，用于表示一个客户对象，该类包含了客户的姓名、地址等信息。现在需要在该类中添加一个新的属性，即客户的信用度 credit，但同时要限制信用度的范围在 0 到 100 之间，并且在修改信用度时要触发相应的事件通知。

首先可以将信用度属性设置为私有属性，然后使用 Self Encapsulate Field 重构，在该类中添加一个 getter 和 setter 方法来访问该属性，并在 setter 方法中添加相应的限制条件和事件通知逻辑。

public class Customer {
   
    private String name;
    private String address;
    private int credit;
    
    // getter and setter methods for name, address
    
    public int getCredit() {
   
        return credit;
    }
    
    public void setCredit(int credit) {
   
        if (credit < 0) {
   
            credit = 0;
        } else if (credit > 100) {
   
            credit = 100;
        }
        
        this.credit = credit;
        notifyCreditChanged();
    }
    
    private void notifyCreditChanged() {
   
        // send notification to interested parties
    }
}

在上述代码中，将信用度属性设置为私有属性，然后添加了一个名为 getCredit() 的 getter 方法和一个名为 setCredit() 的 setter 方法。在 setter 方法中，对信用度进行了范围限制，并在修改属性值后触发了一个名为 notifyCreditChanged() 的事件通知方法。

客户端可以通过调用 getCredit() 和 setCredit() 方法来获取和设置客户的信用度，这样就可以保证在任何时候都能够对信用度进行有效的控制和管理。

Customer customer = new Customer();
// set customer's name, address
customer.setCredit(80);
int credit = customer.getCredit();

通过使用 Self Encapsulate Field 重构，成功将信用度属性进行了封装，并且添加了相应的控制和管理逻辑，同时也保留了原有 Customer 类的功能和行为。需要注意的是，在使用 Self Encapsulate Field 重构时，要确保 getter 和 setter 方法的实现是正确和合理的，并且考虑到类的封装性和保护性等因素，确保程序的整体结构和功能不会发生变化。

Replace Data Value with Object (以对象取代数据值)

它的主要目的是将一个或多个相关的数据值封装成一个对象来实现更灵活、更可扩展、更易维护的代码结构。

举个例子，假设有一个名为 Order 的类，用于表示一个订单对象，该类包含了订单号、订单日期、客户信息等数据。其中客户信息由客户名称和地址组成，现在需要增加一个新的属性，即客户电话。可以考虑使用 Replace Data Value with Object 重构，将客户信息封装成客户对象，使其更容易进行管理和扩展。

首先可以定义一个名为 Customer 的类，用于表示客户对象，该类包含了客户名称、地址和电话号码等信息，然后在 Order 类中将客户信息改为一个指向 Customer 对象的引用。

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

public class Order {
   
    private int orderId;
    private Date orderDate;
    private Customer customer;
    
    // getter and setter methods for orderId, orderDate
    
    public Customer getCustomer() {
   
        return customer;
    }
    
    public void setCustomer(Customer customer) {
   
        this.customer = customer;
    }
}

在上述代码中，定义了一个名为 Customer 的类，用于表示客户对象，并在 Order 类中将客户信息改为一个指向 Customer 对象的引用。客户端可以通过创建 Customer 对象，并将其作为参数传入 Order 对象来进行操作。

Customer customer = new Customer();
// set customer's name, address, phone
Order order = new Order();
// set order's orderId, orderDate
order.setCustomer(customer);

通过使用 Replace Data Value with Object 重构，成功将客户信息封装成客户对象，并且添加了相应的控制和管理逻辑，同时也保留了原有 Order 类的功能和行为。需要注意的是，在使用 Replace Data Value with Object 重构时，要确保新定义的对象能够满足需求，同时也要考虑程序的依赖关系和设计初衷等因素，确保程序的整体结构和功能不会发生变化。

Change Value to Reference (将值对象改为引用对象)

它的主要目的是将一个或多个相同的值对象封装成共享的、可共享的引用对象来实现更灵活、更可扩展、更节省内存的代码结构。

举个例子，假设有一个名为 Employee 的类，用于表示一个员工对象，该类包含了员工编号、员工姓名、员工部门等数据。其中员工部门是一个值对象，由部门名称和部门经理等属性组成，现在需要增加一个新的属性，即部门电话。可以考虑使用 Change Value to Reference 重构，将部门信息封装成共享的引用对象 Department，以提高代码的可重用性和内存使用效率。

首先可以定义一个名为 Department 的类，用于表示部门对象，该类包含了部门名称、部门经理和部门电话等信息，然后在 Employee 类中将部门信息改为一个指向 Department 对象的引用。

public class Department {
   
    private String name;
    private String manager;
    private String phone;
    
    // getter and setter methods for name, manager, phone
}

public class Employee {
   
    private int empId;
    private String empName;
    private Department department;
    
    // getter and setter methods for empId, empName
    
    public Department getDepartment() {
   
        return department;
    }
    
    public void setDepartment(Department department) {
   
        this.department = department;
    }
}

在上述代码中，定义了一个名为 Department 的类，用于表示部门对象，并在 Employee 类中将部门信息改为一个指向 Department 对象的引用。客户端可以通过创建 Department 对象，并将其作为参数传入 Employee 对象来进行操作。

Department department = new Department();
// set department's name, manager, phone
Employee employee = new Employee();
// set employee's empId, empName
employee.setDepartment(department);

通过使用 Change Value to Reference 重构，成功将部门信息封装成共享的引用对象 Department，并且添加了相应的控制和管理逻辑，同时也保留了原有 Employee 类的功能和行为。需要注意的是，在使用 Change Value to Reference 重构时，要确保新定义的对象能够满足需求，并且具有良好的可维护性和扩展性等特点，确保程序的整体结构和功能不会发生变化。

Change Reference to Value（将引用对象改为值对象）

它的主要目的是将一个或多个相关的引用对象转换成值对象，以提高代码的可维护性和性能。

举个例子，假设有一个名为 Customer 的类，用于表示一个客户对象，该类包含了客户名称、客户地址和电话号码等属性。现在需要将客户地址改为值对象，即 Address 类，由于客户地址可能存在多个，如果每个地址都作为独立的对象存储，则会浪费大量的内存空间。可以考虑使用 Change Reference to Value 重构，将地址信息封装成值对象 Address，以提高代码的性能和可维护性。

首先可以定义一个名为 Address 的类，用于表示地址对象，该类包含了省份、城市和详细地址等信息。然后在 Customer 类中将地址信息改为 Address 对象的属性。

public class Address {
   
    private String province;
    private String city;
    private String detail;

    // getter and setter methods for province, city, detail
}

public class Customer {
   
    private String name;
    private Address address;
    private String phone;

    // getter and setter methods for name, phone

    public Address getAddress() {
   
        return address;
    }

    public void setAddress(Address address) {
   
        this.address = address;
    }
}

在上述代码中，定义了一个名为 Address 的类，用于表示地址对象，并在 Customer 类中将地址信息改为 Address 对象的属性。客户端可以通过创建 Address 对象，并将其作为参数传入 Customer 对象来进行操作。

Address address = new Address();
// set address's province, city, detail
Customer customer = new Customer();
// set customer's name, phone
customer.setAddress(address);

通过使用 Change Reference to Value 重构，将引用对象 Address 转换成值对象 Address，成功优化了内存空间的使用，同时也保留了原有 Customer 类的功能和行为。需要注意的是，在使用 Change Reference to Value 重构时，要确保新定义的对象能够满足需求，并且将对象转换成值对象不会影响程序的逻辑和功能。

Replace Array with Object（以对象取代数组）

它的主要目的是通过创建一个新的对象来取代既有的数组结构，从而提高代码的可维护性和可扩展性。

举个例子，假设有一个名为 Students 的类，用于表示一个学生对象数组，该类包含了学生姓名、学号、成绩等属性。现在需要增加一个新的属性，即学生所在的班级，可以考虑使用 Replace Array with Object 重构，将学生信息封装成一个 Student 类对象，以实现更灵活、更可维护的代码结构。

首先可以定义一个名为 Student 的类，用于表示学生对象，该类包含了学生姓名、学号、班级和成绩等信息。然后在 Students 类中将学生信息改为 Student 对象的数组。

public class Student {
   
    private String name;
    private int id;
    private String className;
    private double score;

    // getter and setter methods for name, id, className, score
}

public class Students {
   
    private Student[] students;

    // getter