java工程师成神之路从零开始学习（Java对象）

以下内容都是我跟着《深入理解java核心技术》这本书，一边学习一边抄录的内容。单纯的只是为了学习、巩固自己的知识点。

Java是一门面向对象编程语言，在Java中，所有的实体都是对象，而Java提供了一些特殊的类，这些类可以帮助开发人员更好地管理这些对象。

3.1 Object 类

Object类是Java类库中的根类，所有类都直接或间接地继承自这个类。 Object类定义了一些有用的方法，如toString，hashCode和equals，它们可以帮助开发人员更好地管理对象。

Java 中的 Object 类是所有类的根类，定义了一些常用的方法，如下：

• toString(): 返回一个字符串，该字符串代表该对象的字符串表示形式。
• equals(Object obj): 比较两个对象是否相等。
• hashCode(): 返回该对象的哈希码。
• getClass(): 返回该对象的运行时类。
• clone(): 创建并返回该对象的副本。
• finalize(): 用于垃圾回收。当垃圾回收器准备回收该对象时，该方法会被自动调用。
• wait(): 该方法用于协调线程之间的同步。
• notify() 和 notifyAll(): 该方法用于唤醒等待该对象锁的线程。

这些方法是每个 Java 对象都可以使用的基本方法。开发人员可以重写这些方法以获得更多的灵活性。

3.2 JavaBean

JavaBean是Java语言提供的一种标准，用于定义Java对象的组件。 JavaBean类必须遵循特定的规则，如必须有一个无参数的构造函数和公共的getter和setter方法，这些方法可以访问和修改该对象的属性。

Java Bean 是 Java 编程语言中的一种规范。要满足 Java Bean 标准，一个类必须满足以下条件：

• 具有默认（无参数）构造函数。

• 所有属性是私有的，并使用私有字段存储。

• 具有公共的 getter 和 setter 方法，可以读取和设置私有属性的值。

• 实现 java.io.Serializable 接口，可以将 Bean 序列化并存储到磁盘或传输到网络。

• 实现 java.beans.JavaBeans API 接口，以支持 Java Bean 的可视化操作。

Java Bean 的这些特征使得它们可以在 Java 程序的不同部分之间传递和复用。它们也允许程序员使用可视化工具，例如 NetBeans 和 Eclipse，在不编写代码的情况下生成 Java Bean。

3.3 equals和hashCode的关系

Java中的equals和hashCode方法是对象的两个重要的方法。equals方法用于比较两个对象是否相等，hashCode方法用于获取对象的哈希值。如果两个对象相等，则它们的hashCode值必须相同。因此，如果覆盖了equals方法，也应该覆盖hashCode方法。

equals 和 hashCode 方法是 Java 中的重要方法，它们是 Java 中实现对象比较和哈希表结构的关键。

equals 方法用于判断两个对象是否相等，并且默认的实现是比较对象的地址。但是，通常情况下，我们希望比较对象的内容，而不是地址，因此需要重写 equals 方法。

hashCode 方法用于生成一个对象的哈希码，它是一个整数，用于识别对象。如果两个对象相等（通过 equals 方法判断），那么它们的 hashCode 值也应该相等。如果对象的 hashCode 值不相等，那么这两个对象不可能相等。

因此，equals 和 hashCode 方法是紧密相关的，当我们重写 equals 方法时，也需要重写 hashCode 方法，以维护它们之间的关系。这样，我们才能确保使用哈希表结构时的正确性。

3.4 对象的clone方法

Java 中的 clone 方法是用来创建一个与源对象完全相同的新对象，该方法位于 java.lang.Object 类中。使用 clone 方法时，必须实现 java.lang.Cloneable 接口，否则会抛出 CloneNotSupportedException 异常。

如果类中的所有字段都是基本数据类型或者字符串，那么直接调用 super.clone() 即可，但如果类中还包含其他对象，那么这些对象的引用仍然会指向原对象中的引用，而不是指向一个新的对象，此时需要对对象进行深拷贝。

注意：对于对象的克隆不仅要关注它本身的属性，也要考虑它所包含的其他对象的属性是否需要克隆。如果包含的对象不需要克隆，那么此时实现浅拷贝即可。

3.4.1 深拷贝和浅拷贝

深拷贝和浅拷贝是指对于一个对象的复制，分别指的是复制出的对象的数据类型和引用类型的拷贝情况。

浅拷贝：浅拷贝只是复制了对象本身，并不复制它所引用的对象。如果对象本身是基本数据类型，那么这个拷贝就是深拷贝，如果对象本身是引用类型，那么浅拷贝只复制了对象本身的引用，并没有复制引用的对象。

深拷贝：深拷贝不仅复制了对象本身，还复制了它所引用的对象，以及这个对象引用的对象，直到所有的对象都复制了一遍。深拷贝保证了对象和它所引用的对象都是独立的，互相不影响。

Java 中的 Object 类实现了浅拷贝，如果要实现深拷贝，则需要重写 clone 方法，并在 clone 方法中添加所有引用类型的对象的深拷贝代码。

class Address {
    private String city;
    private String street;

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }
}

class Person implements Cloneable {
    private String name;
    private Address address;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

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

    // 浅拷贝
    public Person shallowClone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    // 深拷贝
    public Person deepClone() {
        try {
            Person person = (Person) super.clone();
            person.address = new Address(this.address.getCity(), this.address.getStreet());
            return person;
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("Shanghai", "xxRoad");
        Person person1 = new Person("silence", address);
        Person person2 = person1.shallowClone();
        Person person3 = person1.deepClone();

        System.out.println(person1.getAddress() == person2.getAddress());  // true
        System.out.println(person1.getAddress() == person3.getAddress());  // false
    }
}

在上面的例子中，Person 类拥有两个方法 shallowClone 和 deepClone，分别表示浅拷贝和深拷贝。我们在 Main 类的 main 方法中分别对两个对象进行了比较，并且输出了结果，从而得知浅拷贝和深拷贝的区别。