Object类
Object 是java中所有类的根类
所有类型直接或间接继承自Object类

构造方法：
Object()
学习常用的方法：
public int hashCode():返回该对象的哈希码值。
public final Class getClass():返回此 Object 的运行时类。
public String toString():返回该对象的字符串表示。建议所有子类都重写此方法。
getClass().getName() + '@' + Integer.toHexString(hashCode())
public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。
protected void finalize():当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
protected Object clone():创建并返回此对象的一个副本。
hashCode()
hashCode()是从内存地址转换来的，代表了一个对象“的身份证号”
不同的对象调用hashCode()得出不同的哈希值
（对象的哈希值不同，就说明不是一个对象）
equals(Object obj)
Object类型原生的equal()方法代码如下：

public boolean equals(Object obj) {
     return (this == obj);// 比较内存地址值，换句话说，默认情况下，只能是在堆上，是同一个内存地址时，才会返回true
}

/**
 * 给自定义类型Student，重写equals()方法，让Student的对象
 * 进行“相等”比较，让对象之间具有比较功能
 */
@Override
public int hashCode() {
      // TODO Auto-generated method stub
      int i = super.hashCode();
      return (int) (i * 31 + System.currentTimeMillis());
}
@Override
public boolean equals(Object obj) {
      // return super.equals(obj);
      // 我们要对相比所有的成员变量是否
      // Student stu = (Student) obj;// ClassCastException
      // 优化程序的执行效率，先判断地址值，如果是同一块内存地址，就直接返回true
      if (this == obj) {
            return true;
      }
      // instanceof 判断一个对象，是否是 某一个类型的实例，来避免向下类型转换时的异常ClassCastException
      if (obj instanceof Student) {
            Student stu = (Student) obj;
            // (str1.equals(str2))
            if (this.getName().equals(stu.getName()) && this.getAge() == stu.getAge() && this.getBirth().equals(stu.getBirth())) {
                return true;
            }
      }
      return false;
}

finalize()

protected void finalize() throws Throwable {
    // 比如，这里打开了文件，（外部资源）
    // gc 的特点，不是立马执行的，我们直接执行finalize()方法，不能直接调用gc来清除内存
    super.finalize();
}

clone()

Object objclone = stu.clone();
// 对象的clone，之后强制类型转换
Student stuclone = (Student) objclone;
stu.setName("小可爱");// 改变了基本数据的值，不会影响克隆后的值
stu.changDate();// 改变了引用类型的值，会影响克隆后的值，也就说，两个应用类型指向了同一个对象
// 现在的问题是：stu 和 stuclone 之间是什么关系？
// 回答：stu 和stuclone 克隆关系，地址值不一样，成员变量一样
// 这种copy 我们通常叫 shadow clone，浅克隆，浅拷贝
// 还有与之对应的 叫 深拷贝，深度克隆，deep clone
// 深度克隆的意思是：在工作中，有可能需要 引用类型的值，也同时需要copy一份
// 默认JDK 不提供深度克隆，如果需要深度克隆，需要工程师自己想办法实现之

总结来说，浅拷贝 是copy 成员变量的时候，只copy基本数据类型
（和String类型，因为String类型是一种特殊的引用类型，
在这里可以看作“常量”，因为JDK设计者，将String类型设计为“不可变”的字符串）；
引用数据类型不copy（引用类型 所指向对象，不再克隆，只保留一份，相当于两个变量指向了同一个对象）

Cloneable 接口，没有抽象方法,空接口，在jdk中还有很多，这种接口，标记接口

// 重写clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
      // TODO Auto-generated method stub
      // Student stu = (Student) super.clone();
      // if(stu.getAddress() != null){
      // stu.setAddress(null);
      // }
      // return super.clone();
      // return super.clone();
      Student stu = (Student) super.clone();// 只执行浅克隆
      // 如果要执行深度克隆，我们可以逐个 对引用类型 进行 浅克隆
      if (stu.birth != null) {
            Object obj = this.birth.clone();
            Date d = (Date) obj;
            stu.setBirth(d);
      }
      if (stu.address != null) {
            Object obj = this.address.clone();
            Address ad = (Address) obj;
            stu.setAddress(ad);
      }
      return stu;
}

对象的克隆（浅克隆和深克隆的示意图）