Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。

Java Object 类 - 图1
Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。
Object 类可以显示继承，也可以隐式继承，以下两种方式时一样的：
显示继承:

  1. public class Runoob extends Object{ }

隐式继承:

  1. public class Runoob { }

类的构造函数

构造方法 描述
Object() 构造一个新对象

类的方法

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个

方法 描述
protected Object clone() 创建并返回一个对象的拷贝
int hashCode() 获取对象的 hash 值
boolean equals(Object obj) 比较两个对象是否相等,指示其他某个对象是否与此对象“相等”
如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符 的对象地址比较，只要不是同一个对象，结果必然为false
protected void finalize() 当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。
Class<?> getClass() 获取对象的运行时对象的类
void notify() 唤醒在该对象上等待的某个线程
void notifyAll() 唤醒在该对象上等待的所有线程
String toString() 返回对象的字符串表示形式, 其实该字符串内容就是对象的类型+@+内存地址值。
void wait() 让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
void wait(long timeout) 让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数设置的timeout超时时间。
void wait(long timeout, int nanos) 与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。

Object覆盖重写示例

  1. import java.util.*;
  3. class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public int hashCode() {
  33.         return Objects.hash(name, age);
  34.     }
  36.     @Override
  37.     public boolean equals(Object o) {
  38.         if (this == o) return true; // 如果对象地址一样，则认为相同
  39.         if (o == null || getClass() != o.getClass()) return false; // 如果参数为空，或者类型信息不一样，则认为不同
  40.         Student student = (Student) o;
  41.         return age == student.age && Objects.equals(name, student.name); //要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
  42.     }
  44.     @Override
  45.     public String toString() {
  46.         return "person{" + "name='" + name + '\'' + ", age=" + age + '}';
  47.     }
  48. }
  51. public class Test {
  52.     public static void main(String[] args) {
  53.         //创建集合对象   该集合中存储 Student类型对象
  54.         HashSet<Student> stuSet = new HashSet<Student>();
  55.         //存储 
  56.         stuSet.add(new Student("于谦", 1));
  57.         stuSet.add(new Student("郭德纲", 44));
  58.         stuSet.add(new Student("郭德纲", 44));
  59.         stuSet.add(new Student("于谦", 43));
  60.         stuSet.add(new Student("郭麒麟", 23));
  62.         for (Student stu2 : stuSet) {
  63.             System.out.println(stu2);
  64.         }
  65.     }
  66. }
  68. /* 
  69. 执行结果：
  70. person{name='郭德纲', age=44}
  71. person{name='于谦', age=43}
  72. person{name='郭麒麟', age=23}
  73. person{name='于谦', age=1}
  74. */

java.util.Objects类

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？
JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的)，用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

  1. public static boolean equals(Object a, Object b) //判断两个对象是否相等。
  3. public static boolean equals(Object a, Object b) {  
  4.     return (a == b) || (a != null && a.equals(b));  
  5. }