一切类的祖先Object类及Objects类

class Object（java.lang）

注：一切Java类的祖先类。

private static native void registerNatives();

static {
    registerNatives();
}

• 定义了registerNatives本地方法，实现注册该类中除该方法外所有的本地方法

  • native关键字修饰的方法称为本地化方法，是联系Java程序和底层主机操作系统的连接方法

• static静态代码块中调用注册本地方法的的方法，实现注册本地方法的作用

  • 在类被加载后，方便的调用本地化方法，而无需关心底层的实现原理

  • 若本地方法实现被修改，可通过重新调用注册本地方法来实现重新加载更新

public final native Class<?> getClass();

• 获取实例对象在内存中的实际类型

例1：获取对象实际类型

Object obj = new Date();
System.out.println("实例对象实际类型：" + obj.getClass().getName());
//输出结果：实例对象实际类型：java.util.Date

public native int hashCode();

• 类实例对象的hash码值，该值是根据一定规则将与对象相关的信息映射成的一个数值。
• 由于不同实例对象的hash码值不同，可通过比较对象的hash码值来判断对象是否为同一个对象。

public boolean equals(Object obj) {
    return (this == obj);
}

• 比较当前对象和传入对象是否相等，若相等返回true，否则返回false。
• “==”比较的是两个对象在内存中的地址是否相同。在实际应用中，有些类对该方法进行了重写，例如：String类、Math类。

protected native Object clone() throws CloneNotSupportedException;

public interface Cloneable {}

• 快速的创建一个对象的副本（克隆）。
• 该方法被protected关键词修饰，所以类必须继承于Object类，并且实现Cloneable接口才能使用。否则会抛出CloneNotSupportedException异常。
• 副本对象不是对原对象的引用，而是创建了一个相同内容的新对象。
• Cloneable接口虽然没有定义任何方法，但是在对象克隆时是必须要实现的。

例2：对象克隆简用

public class MyClone implements Cloneable {
	
	private String name;
	
	public MyClone(String name) {
		this.name = name;
	}
    
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
    
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	public static void main(String[] args) throws CloneNotSupportedException {
		MyClone obj = new MyClone("小明");
		MyClone obj1 = (MyClone) obj.clone();
		System.out.println("两个对象是否同一个对象：" + obj.equals(obj1));
        //输出结果：两个对象是否同一个对象：false
        System.out.println("克隆对象名称：" + obj1.getName());
        //输出结果：克隆对象名称：小明
	}

}

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

• 获取对象的字符串描述，默认为“类全路径名@十六进制表示的hash码值”。

public final native void notify();

public final native void notifyAll();

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
            "nanosecond timeout value out of range");
    }

    if (nanos > 0) {
        timeout++;
    }

    wait(timeout);
}

public final void wait() throws InterruptedException {
    wait(0);
}

• notify和notifyAll方法用来唤醒在此对象监视器上等待的进程。
• wait方法用来设置线程等待。timeout表示要等待的毫秒值，nanos表示设置额外等待的毫微秒值（范围在0~999999之间）。

protected void finalize() throws Throwable { }

• 垃圾回收器准备释放内存的时候，会先调用finalize方法。

final class Objects（java.util）

注：该类是final的，并且它的构造方法是私有的。表示该类不能被其他类继承或修改。

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

public static boolean deepEquals(Object a, Object b) {
    if (a == b)
        return true;
    else if (a == null || b == null)
        return false;
    else
        return Arrays.deepEquals0(a, b);
}

//Arrays.deepEquals0方法
static boolean deepEquals0(Object e1, Object e2) {
    assert e1 != null;
    boolean eq;
    if (e1 instanceof Object[] && e2 instanceof Object[])
        eq = deepEquals ((Object[]) e1, (Object[]) e2);
    else if (e1 instanceof byte[] && e2 instanceof byte[])
        eq = equals((byte[]) e1, (byte[]) e2);
    else if (e1 instanceof short[] && e2 instanceof short[])
        eq = equals((short[]) e1, (short[]) e2);
    else if (e1 instanceof int[] && e2 instanceof int[])
        eq = equals((int[]) e1, (int[]) e2);
    else if (e1 instanceof long[] && e2 instanceof long[])
        eq = equals((long[]) e1, (long[]) e2);
    else if (e1 instanceof char[] && e2 instanceof char[])
        eq = equals((char[]) e1, (char[]) e2);
    else if (e1 instanceof float[] && e2 instanceof float[])
        eq = equals((float[]) e1, (float[]) e2);
    else if (e1 instanceof double[] && e2 instanceof double[])
        eq = equals((double[]) e1, (double[]) e2);
    else if (e1 instanceof boolean[] && e2 instanceof boolean[])
        eq = equals((boolean[]) e1, (boolean[]) e2);
    else
        eq = e1.equals(e2);
    return eq;
}

• 两个方法都是判断两个对象是否相等。若为数组对象，使用deepEquals方法进行深度比较。

public static int hashCode(Object o) {
    return o != null ? o.hashCode() : 0;
}

public static int hash(Object... values) {
    return Arrays.hashCode(values);
}

//Arrays.hashCode
public static int hashCode(Object a[]) {
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

• hashCode和hash方法用于获取对象或者对象集合的hash码值。若对象为空，则返回0。
• 对象数组的hash码值（result = 31 * result + 单个对象hash码值）。

public static String toString(Object o) {
    return String.valueOf(o);
}

public static String toString(Object o, String nullDefault) {
    return (o != null) ? o.toString() : nullDefault;
}

• 获取对象的字符串表示，若对象为空，则可通过传递第二个参数来设置默认返回字符串。

public static <T> int compare(T a, T b, Comparator<? super T> c) {
    return (a == b) ? 0 :  c.compare(a, b);
}

• 通过设置的比较器来比较两个对象的大小，若两个对象为同一对象，则返回0。

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

public static <T> T requireNonNull(T obj, String message) {
    if (obj == null)
        throw new NullPointerException(message);
    return obj;
}

public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier) {
    if (obj == null)
        throw new NullPointerException(messageSupplier.get());
    return obj;
}

• 判断对象是否为空，若为空，则根据设置的异常内容抛出NullPointerException异常。若不为空，则返回原对象。

public static boolean isNull(Object obj) {
    return obj == null;
}

public static boolean nonNull(Object obj) {
    return obj != null;
}

• 判断对象是否为空。