Java Object

超类Object

java中，所有类都默认继承一个超类，最顶层类，就是Object类。

jdk类文件描述

/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */

上面提到，包括数组，都实现了Object的方法。

不管是新建的类，或者继承的类，顶类还是object对象。如果编写自定义类没有 extends 父类，那么父类就是Object

既然Object是一个顶部超类，自然特殊重要，并且公开类方法，其他类也有，需要了解

公共方法

getClass()

对象调用此方法，获取对象的类文件对象，即Class实例对象

public final native Class<?> getClass(); //native 标识，说明是调用jvm底层方法(C语言) final

hashCode()

获取哈希码方法，java中区分对象，分配对象位置，需要用到，默认应该是与对象内存地址有关的值，且唯一。

public native int hashCode(); //native 可以重写

equals(Object object)

用于判断两个对象是否相等，子类可以重写自定义

public boolean equals(Object obj) {
        return (this == obj); //这里 == 判断的是两个对象在内存中的地址值
}

toString()

对象标志方法，默认是类名+@+hashCode()值，可重写自定义

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

wait()

java线程相关方法，在多线程场景，cpu资源分配问题上使用，可使当前线程等待
（搭配synchronize使用）。调用wait时，线程会释放对应的锁资源
wait(long timeout) 一样，就是可以设置wait时间，更细节，机制是一样的。 wait() 则调用 wait(0);

public final void wait() throws InterruptedException {
        wait(0);
}	
public final native void wait(long timeout) throws InterruptedException; //native & final

notify()

与wait()方法对应，锁资源，试图唤醒其他wait 线程（某一个）,notifyAll() 则是唤醒所有等待线程

public final native void notify();  //native & final

示例

启动多个线程，按照预定顺序启动（数值大的优先启动，通过 wait 和 notify达到控制效果）

package javabasis.lang;

public class MyThread extends Thread{

	
	private static Object lock = new Object(); //锁对象
	
	private static volatile int threshold;  // 线程启动阈值
	
	
	private int num;  //对象标识

	public MyThread(int num) { //有参构造
		super();
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	/*
	 * 重写线程run方法
	 */
	@Override
	public void run() {
		synchronized (lock) {
			
			while(this.num < threshold) { // 数值小于阈值，不能执行任务，进入等待状态
				try {
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			threshold --; // 没启动一个线程任务，阈值减一
			System.out.println("..>" + this.getName() + ":num="+ this.num +"*执行任务");
			lock.notifyAll(); //唤醒其他等待线程(与lock锁关联的线程)
		}
	}
	
	
	public static void main(String[] args) {
		int h = 31; 
		threshold = h - 1;  //阈值为30
		for (int i = 0; i < h; i ++) {
			new MyThread(i).start();  //启动线程
		}
	}
	
}

/*控制台输出结果
..>Thread-30:num=30*执行任务
..>Thread-29:num=29*执行任务
..>Thread-28:num=28*执行任务
..>Thread-27:num=27*执行任务
..>Thread-26:num=26*执行任务
..>Thread-25:num=25*执行任务
..>Thread-24:num=24*执行任务
..>Thread-23:num=23*执行任务
..>Thread-22:num=22*执行任务
..>Thread-21:num=21*执行任务
..>Thread-20:num=20*执行任务
..>Thread-19:num=19*执行任务
..>Thread-18:num=18*执行任务
..>Thread-17:num=17*执行任务
..>Thread-16:num=16*执行任务
..>Thread-15:num=15*执行任务
..>Thread-14:num=14*执行任务
..>Thread-13:num=13*执行任务
..>Thread-12:num=12*执行任务
..>Thread-11:num=11*执行任务
..>Thread-10:num=10*执行任务
..>Thread-9:num=9*执行任务
..>Thread-8:num=8*执行任务
..>Thread-7:num=7*执行任务
..>Thread-6:num=6*执行任务
..>Thread-5:num=5*执行任务
..>Thread-4:num=4*执行任务
..>Thread-3:num=3*执行任务
..>Thread-2:num=2*执行任务
..>Thread-1:num=1*执行任务
..>Thread-0:num=0*执行任务

*/

clone()

对象克隆方法，是jvm的native方法，更具对象字节复制，真正需要clone的时候，需要实现CloneAble接口，重写Object的clone()方法

protected native Object clone() throws CloneNotSupportedException;  

finalize()

与jvm内存回收有关的方法

protected void finalize() throws Throwable { }

实际开发中用到比较少，想了解finalize更多，可以查阅资料

https://www.cnblogs.com/langtianya/p/4401062.html