Object类和Any详解

Object类和Any详解

Any

Any类是kotlin类结构的跟，每个kotlin都继承或间接继承于Any类

/**
 * The root of the Kotlin class hierarchy. Every Kotlin class has [Any] as a superclass.
 */
public open class Any {
	// kotlin的函数可以没有函数体，其不是Abstract方法，所以子类不必重写。
	public open operator fun equals(other: Any?): Boolean
	public open fun hashCode(): Int
	public open fun toString(): String
}
复制代码

里面有三个open的方法equals、hashCode和toString，其中equals和hashCode如果需要修改就必须同时修改。

Object

同样java中Object也是class结构的根，每个类继承或者间接继承于Object

package java.lang;

public class Object {
	public Object() {
	}

	private static native void registerNatives();

	public final native Class<?> getClass();

	public native int hashCode();

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

	protected native Object clone() throws CloneNotSupportedException;

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

	public final native void notify();

	public final native void notifyAll();

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

	public final void wait(long var1, int var3) throws InterruptedException {
		if (var1 < 0L) {
			throw new IllegalArgumentException("timeout value is negative");
		} else if (var3 >= 0 && var3 <= 999999) {
			if (var3 > 0) {
				++var1;
			}

			this.wait(var1);
		} else {
			throw new IllegalArgumentException("nanosecond timeout value out of range");
		}
	}

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

	protected void finalize() throws Throwable {
	}

	static {
		registerNatives();
	}
}
复制代码

相比于Kotlin，java中的class方法丰富的多，十二个。其中7个本地方法包含一个静态本地方法，5个可以被子类覆盖的方法

private static native void registerNatives();

static {
    registerNatives();
}
复制代码

静态本地方法在类加载时执行。该方法的作用是通过类加载器加载一些本地方法到JVM中。Object类在被加载时，会加载一些methods中的本地方法到JVM中如下：

static JNINativeMethod methods[] = {
	{“hashCode”, “()I”, (void *)&JVM_IHashCode},
	{“wait”, “(J)V”, (void *)&JVM_MonitorWait},
	{“notify”, “()V”, (void *)&JVM_MonitorNotify},
	{“notifyAll”, “()V”, (void *)&JVM_MonitorNotifyAll},
	{“clone”, “()Ljava/lang/Object;”, (void *)&JVM_Clone},
};
复制代码

@Contract(pure = true) public final native Class<?> getClass();

返回该对象的类的Class对象。Class对象可以用于反射等场景。

public native int hashCode();

返回对象的哈希值，主要用于HashMap的hash tables。

哈希需要注意的几点：

• 相等的对象必须要有相同的哈希码

• 不相等的对象一定有着不同的哈希码——错！

• 有同一个哈希值的对象一定相等——错！

• 重写equals时必须重写hashCode

equals

 public boolean equals(Object var1) {
	return this == var1;
}
复制代码

判断引用是否指向同一个地址，就是判断两个引用指向的对象是否是同一个对象， String重写了该方法，判断字符串是否相等。

protected native Object clone() throws CloneNotSupportedException;

该方法用于拷贝。要调用该方法需要类实现Cloneable接口，否则抛出CloneNotSupportedException。

浅拷贝，重写clone方法，调用super.clone()：

public class TestOne implements Cloneable {
	@NonNull
	@Override
	protected TestOne clone() {
		TestOne obj = null;
		try {
			obj = (TestOne) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return obj;
	}
}
复制代码

深拷贝

public class TestTwo implements Cloneable {
	public TestOne var;
	@NonNull
	@Override
	protected TestTwo clone() {
		TestTwo obj = null;
		try {
			obj = (TestTwo) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		obj.var = obj.var.clone();
		return obj;
	}
}
复制代码

public String toString()

返回类名和对象的哈希值的十六进制字符串，推荐子类重写该方法。

notify()、notifyAll()、wait()方法

从1.0版开始，Java中的每一个对象都有一个内部锁。如果一个方法用synchronized关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，线程必须获得内部的对象锁。

public synchronize void method(){
	method body
}
等同于
public void method(){
	this.intrinsicLock.lock();
	try{
		method body
	}
	finally{ this.intrinsicLock.unlock();}
}
复制代码

从这个示例我们即可看出上面几个方法的作用。

public final native void notify();

随机选择一个在该对象上调用wait方法的线程，解除其阻塞状态。该方法只能在一个同步方法或同步块中调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

public final native void notifyAll();

解除那些在该对象上调用wait方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

public final void wait() throws InterruptedException

使线程进入等待状态直到它被通知。该方法只能在一个同步方法中调用。如果当前线程不是对象锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

public final void wait(long millis, int nanos) throws InterruptedException

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

参数：millis 毫秒数 nanos 纳秒数 < 1000 000
使线程进入等待状态直到它被通知或者经过指定的时间。这些方法只能在一个同步方法中调用。如果当前线程不是对象锁的持有者该方法抛出一个IllegalMonitorStateException异常。

protected void finalize() throws Throwable

当一个堆空间中的对象没有被栈空间变量指向的时候，这个对象会等待被java回收。

GC特点：

• 当对象不再被程序所使用的时候，垃圾回收器将会将其回收
• 垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他可以尽快回收资源（System.gc()和Runtime.getRuntime().gc()）
• 垃圾回收器在回收某个对象的时候，首先会调用该对象的finalize()方法
• GC主要针对堆内存
• 单例模式的缺点

Any和Object相同点

Kotlin中的Any只存在于编译期，运行期就不存在了。

val any = Any()
println("any:$any ")
println("anyClass:${any.javaClass} ")

val obj = any as Object
synchronized(obj){
	obj.wait()
}
println("obj:$obj ")
println("obj:${any.`class`} ")

I/System.out: any:java.lang.Object@d12ebc1 
I/System.out: anyClass:class java.lang.Object 
I/System.out: obj:java.lang.Object@d12ebc1 
I/System.out: obj:class java.lang.Object 
复制代码

从上面的示例可以看出在runtime，Any变成了Object，在kotlin中也可以将Any强转为Object。

从Kolitn的官方文档 kotlinlang.org/docs/java-i… 可以看到Object对应的就是Any

Kotlin专门处理一些Java类型。这些类型不是按原样从Java加载的，而是映射到相应的Kotlin类型。映射只在编译时起作用，运行时表示保持不变。Java的原语类型映射到相应的Kotlin类型（保持平台类型）

从上面的示例可以看出obj可以any混用，any强转后不仅可以使用notify()等方法，还可以使用Any的扩展方法，如使用 obj.apply { }