使用Object继承和泛型处理一个复杂多变还要多层套用还要变成无限拓展链的数据结构————————（示例）利用 Object 继承和泛型处理员工职位多层嵌套的无限拓展信息链-优快云博客

在实际开发中，我们经常会处理一个极其复杂多层嵌套的数据结构。

我们则涉及到各种各样的重写，尤其是clone,toString,equals这仨。

今天我们就用员工和职位来讲重写和类的处理，更深层次理解Java”能用10个类就绝不用9个“的超包装特点。

一、为啥这仨是被重写大户？

我们贴一段JDK原代码来展示一下。

1.equals

明显得出，对于任何的非基本数据类型，原代码的equals完全就是在比较地址是否相同。这会出现只能this == this的情况。我们需要重写它，使得内容相同就行。

2.toString

这样，如果不重写toString，执行打印的时候就会打印出地址，也就是我们看到的带着@的那么一大串东西。

3.clone

这位更狠，直接几乎就是接口了......

综上，你不重写，你也没法用啊......

二、重写的通常方法

1.equals

在 Java 中重写 equals、toString 和 clone 这三个方法时，存在一套被广泛遵循的通用模式。掌握这套模式可以帮助开发者高效处理复杂对象的比较、打印和复制需求。

@Override
public boolean equals(Object obj) {
    1. 基础校验:
       IF (this == obj) THEN RETURN true
       IF (obj == null OR getClass() != obj.getClass()) THEN RETURN false
       
    2. 类型转换:
       T other = (T) obj
       
    3. 字段比较:
       RETURN 所有关键属性的等值比较表达式
}

对于 equals 方法的重写，标准流程是首先检查两个对象的内存地址是否相同，如果相同则直接返回 true；接着检查传入对象是否为 null 或者是否属于当前类的实例，如果不满足则返回 false；然后将传入对象强制转换为当前类的类型，再对所有关键属性进行逐一比较。比较时需要注意基本数据类型使用 == 运算符，而引用类型则应该使用 Objects.equals 方法以避免空指针异常。对于集合类型的属性，推荐使用 Objects.deepEquals 方法进行深度比较，确保集合中的每个元素都相等。

2.toString

@Override
public String toString() {
    RETURN 类名 + "{" + 
        字段1名 + "=" + 字段1值 + 
        "," + 字段2名 + "=" + 字段2值 + 
        ... + 
        "}"
}

toString 方法的重写模式相对固定，通常是返回一个包含类名和所有重要属性的字符串。标准做法是先拼接类名，后跟一对花括号，括号内按照固定顺序列出每个属性的名称和值，属性之间用逗号分隔。对于嵌套对象，toString 方法会自动递归调用其 toString 方法，因此无需特殊处理。为了提高可读性，属性的列出顺序应该与类定义中的顺序保持一致。

3.clone

@Override
public T clone() throws CloneNotSupportedException {
    1. 浅拷贝基础对象:
       T cloned = (T) super.clone()
       
    2. 深拷贝处理:
       IF (引用类型字段1 != null) THEN
           cloned.引用类型字段1 = 字段1的深拷贝操作
       END IF
       
       IF (集合类型字段 != null) THEN
           cloned.集合类型字段 = new 集合类型()
           FOR (每个元素 e : 集合类型字段) DO
               cloned.集合类型字段.add(e.clone())
           END FOR
       END IF
       
    3. 返回克隆对象:
       RETURN cloned
}

clone 方法的重写需要遵循深拷贝原则。首先调用 super.clone () 获取对象的浅拷贝，然后对所有引用类型的属性进行单独的深拷贝操作。对于集合类型的属性，需要创建一个新的集合实例，并将原集合中的每个元素逐一克隆后添加到新集合中。如果对象存在多层嵌套结构，则每个层级的引用类型都需要进行递归克隆，确保所有层级的对象都是独立的副本。需要特别注意的是，类必须实现 Cloneable 接口才能调用 super.clone () 方法，否则会抛出 CloneNotSupportedException 异常。

三、Examples

示例 1：创建员工信息并添加到链表

import java.util.ArrayList;

public class Example1 {
    public static void main(String[] args) {
        // 创建职位信息
        StringBuilder managerBuilder = new StringBuilder("Manager");
        Position manager = new Position((short) 6, managerBuilder);
        StringBuilder engineerBuilder = new StringBuilder("Engineer");
        Position engineer = new Position((short) 5, engineerBuilder);

        // 创建员工信息
        ArrayList<Position> emp1Positions = new ArrayList<>();
        emp1Positions.add(manager);
        Employee emp1 = new Employee("Alice", "RC234567", 28, emp1Positions);

        ArrayList<Position> emp2Positions = new ArrayList<>();
        emp2Positions.add(engineer);
        Employee emp2 = new Employee("Bob", "RC345678", 35, emp2Positions);

        // 创建链表并添加员工
        LLArrays<Employee> employeeList = new LLArrays<>();
        employeeList.add(emp1);
        employeeList.add(emp2);

        // 打印链表内容
        System.out.println("Employee List: " + employeeList);
    }
}

示例 2：克隆员工数组

import java.util.ArrayList;

public class Example2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建职位信息
        StringBuilder managerBuilder = new StringBuilder("Manager");
        Position manager = new Position((short) 6, managerBuilder);
        StringBuilder engineerBuilder = new StringBuilder("Engineer");
        Position engineer = new Position((short) 5, engineerBuilder);

        // 创建员工信息
        ArrayList<Position> emp1Positions = new ArrayList<>();
        emp1Positions.add(manager);
        Employee emp1 = new Employee("Alice", "RC234567", 28, emp1Positions);

        ArrayList<Position> emp2Positions = new ArrayList<>();
        emp2Positions.add(engineer);
        Employee emp2 = new Employee("Bob", "RC345678", 35, emp2Positions);

        Employee[] employees = {emp1, emp2};

        CloneTools<Employee> cloneTools = e1 -> {
            try {
                return e1.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        };

        LLArrays<Employee> employeeList = new LLArrays<>();
        for (Employee employee : employees) {
            employeeList.add(employee);
        }
        LLArrays<Employee> clonedList = employeeList.cloneArray(employees, cloneTools);

        System.out.println("Original List: " + employeeList);
        System.out.println("Cloned List: " + clonedList);
    }
}

示例 3：验证克隆的独立性

import java.util.ArrayList;

public class Example3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建职位信息
        StringBuilder managerBuilder = new StringBuilder("Manager");
        Position manager = new Position((short) 6, managerBuilder);

        // 创建员工信息
        ArrayList<Position> emp1Positions = new ArrayList<>();
        emp1Positions.add(manager);
        Employee emp1 = new Employee("Alice", "RC234567", 28, emp1Positions);

        CloneTools<Employee> cloneTools = e1 -> {
            try {
                return e1.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        };

        LLArrays<Employee> employeeList = new LLArrays<>();
        employeeList.add(emp1);
        LLArrays<Employee> clonedList = employeeList.cloneArray(new Employee[]{emp1}, cloneTools);

        // 修改原始员工信息
        emp1.getPositions().get(0).getPositionName().append(" (Updated)");

        System.out.println("Original Employee: " + employeeList.get(0));
        System.out.println("Cloned Employee: " + clonedList.get(0));
    }
}