public class Object {
private static native void registerNatives();
static {
registerNatives();
}
/**
* 返回对象的运行时类
* 用例：Number n = 0
* Class<? extends Number> c = n.getClass();
*/
public final native Class<?> getClass();
/**
* 返回对象的hash值，本方法为支持哈希表提供了很多好处，例如:hashmap中
* 1.当一个java应用执行时，一个相同的对象多次调用hashcode方法，这个方法都会返回相同的
* 整数
* 2.根据equals方法，如果两个对象相等，则这两个对象调用hashcode方法必须生成同样的hash值
* 3.根据equals方法，如果两个对象不相等，则这两个对象调用hashcode方法必将生成不同的hash值,
* 注意：两个对象的hashcode值相等，两个对象用equals比较并不一定相等
* 程序员应该意识到，为不同的对象生成不同的hash值将会提高hash表的性能
* @return a hash code value for this object.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.lang.System#identityHashCode
*/
public native int hashCode();
/**
* 比较两个对象相等
* 自反性（reflextive）：对于任何非空的引用值x，x.equals(x)都会返回true
* 对称性（symmetric）：对于任何的非空引用值x和y,只有当y.equals(x)返回true时，x.equals(y)才为true
* 传递性（transitive）：对于任何的非空引用值x和y、z，如果x.equals(y)返回true,y.equals(z)返回true,
* 那么x.equals(z)也将返回true
* 一致性（consistent）:对于任何非空的引用x和y,多次调用x.equals(y)始终返回true或者false的前提是
* equal比较中所有的信息未被修改
* 对于任何的非空引用值x,x.equals(null)始终返回false
* 只有当x,y指向同一个对象时，则x==y才会返回true
* 如果必须要重新equals方法，那么通常也需要重写hashcode方法，根据hashcode方法的协议规范
* 两个相同的对象必须具有相同的hash码
* @param obj the reference object with which to compare.
* @return {@code true} if this object is the same as the obj
* argument; {@code false} otherwise.
* @see #hashCode()
* @see java.util.HashMap
*/
public boolean equals(Object obj) {
return (this == obj);
}
/**
* 该克隆属于浅克隆
* 创建并返回对象的一个副本，副本意味着依赖对对象的类
* 通常的情况：对于任何一个对象x;如果表达式：
* x.clone() != x 返回true
* 那么 x.clone().getClass() == x.getClass()也将返回true
* 但这不是绝对条件，一般情况下：
* x.clone().equals(x)也将返回true
* 依照约定，返回的对象应该通过调用super.clone()获得，如果
* 如果一个类或者他的所有超类(除object)都遵循此约定，则
* x.clone().getClass() == x.getClass()
* 按照约定，此方法返回的对象应该独立于该对象(被克隆的对象)，要想实现这种独立性
* 在supper.clone()返回之前修改他的一个或者多个字段，这通常意味着
* 要复制包含正在被克隆对象的内部“深层结构”的所有可变对象，并使用对副本的引用
* 替换对这些对象的引用，如果一个类只包含基本字段或者是引用的对象是不可变的，
* 那么通常不需要修改super.clone()返回的对象
* Object类的clone方法执行特定的克隆操作，如果一个类没有实现cloneable接口
* 将会抛出CloneNotSupportedException.
* 注意：所有对象都被视为实现了cloneable接口，否则，此方法会创建此对象的类的一个新实例，
* 并像通过分配那样，严格使用此对象相应字段的内容初始化该对象的所有字段；
* 这些字段的内容没有被自我克隆。所以，此方法执行的是该对象的“浅表复制”，而不“深层复制”操作
* Object本身没有实现cloneable接口，因此自身调用object将会在运行时抛出异常
*
* @return a clone of this instance.
* @see java.lang.Cloneable
*/
protected native Object clone() throws CloneNotSupportedException;
/**
* 对象以字符串形式返回，结果是易读的，推荐所有的子类都重新该方法
* Object的toString方法返回一个字符串，该字符串有类名+@+此对象哈希码的无符号十六进制表示组成
* 换句话说，此方法返回的值等价于：
* getClass().getName()+'@'+Integer.toHexString(hashCode())
* @return a string representation of the object.
*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
/**
* 唤醒在此对象上监听等待单个线程，如果所有线程都在这个对象上等待，
* 他们中的其中一个会被唤醒，选择是任意性的，并在实现做出决定时发生，
* 一个线程通过调用wait方法，在对象的监听器上等待
* 直到当前的线程的放弃在该对象上的锁，被唤醒的线程将以常规方式与该对象上的其他线程竞争
* 例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
* 此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：
* 通过执行此对象的同步 (Sychronized) 实例方法。
* 通过执行在此对象上进行同步的 synchronized 语句的正文。
* 对于 Class 类型的对象，可以通过执行该类的同步静态方法。
* 一次只能有一个线程拥有对象的监视器。
*
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @see java.lang.Object#notifyAll()
* @see java.lang.Object#wait()
*/
public final native void notify();
/**
* 唤醒在此对象监听器上等待的所有线程，线程通过调用wait方法在该对象的监听器上
* 等待，被唤醒的线程不能直接执行，直到当前的线程放弃在该对象上的锁。
* 例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
* 此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：
* 通过执行此对象的同步 (Sychronized) 实例方法。 * 通过执行在此对象上进行同步的 synchronized 语句的正文。
*
*/
public final native void notifyAll();
/**
* 导致线程等待，直到其他的线程条用该对象上的notify()或者是notifyAll()方法，或者是超过指定的时间
* 当前的线程必须拥有此对象的监听器
* 此方法导致当前线程（称之为 T）将其自身放置在对象的等待集中，
* 然后放弃此对象上的所有同步要求。出于线程调度目的，线程 T 被禁用，且处于休眠状态，直到发生以下四种情况之一：
* 其他一些线程调用该对象的notify方法，并且线程T被任选为被唤醒线程
* 其他一些线程调用该对象的notifyAll()方法
* 其他一些线程中断线程T
*
* @param timeout 等待时间.
*/
public final native void wait(long timeout) throws InterruptedException;
/**
*
* @param timeout 需要等待的时间.
* @param nanos 额外时间, in nanoseconds range
* 0-999999.
* @exception IllegalArgumentException if the value of timeout is
* negative or the value of nanos is
* not in the range 0-999999.
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @exception InterruptedException if any thread interrupted the
* current thread before or while the current thread
* was waiting for a notification. The <i>interrupted
* status</i> of the current thread is cleared when
* this exception is thrown.
*/
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 >= 500000 || (nanos != 0 && timeout == 0)) {
timeout++;
}
wait(timeout);
}
/**
* 默认的wait方法
*/
public final void wait() throws InterruptedException {
wait(0);
}
/**
* 当垃圾收集器确定该对象没有被更多引用时，有该对象的垃圾回收器调用
* 子类重写改方法已配置资源或者执行其他清除操作
* finalize 的常规协定是：当 JavaTM 虚拟机已确定尚未终止的任何线程无法再通过任何方法访问此对象时，
* 将调用此方法，除非由于准备终止的其他某个对象或类的终结操作执行了某个操作。
* finalize 方法可以采取任何操作，其中包括再次使此对象对其他线程可用；
* 不过，finalize 的主要目的是在不可撤消地丢弃对象之前执行清除操作。
* 例如，表示输入/输出连接的对象的 finalize 方法可执行显式 I/O 事务，以便在永久丢弃对象之前中断连接。
* Object 类的 finalize 方法执行非特殊性操作；它仅执行一些常规返回。Object 的子类可以重写此定义。
* Java 编程语言不保证哪个线程将调用某个给定对象的 finalize 方法。
* 但可以保证在调用 finalize 时，调用 finalize 的线程将不会持有任何用户可见的同步锁定。
* 如果 finalize 方法抛出未捕获的异常，那么该异常将被忽略，并且该对象的终结操作将终止。
* 在启用某个对象的 finalize 方法后，将不会执行进一步操作，
* 直到 Java 虚拟机再次确定尚未终止的任何线程无法再通过任何方法访问此对象，
* 其中包括由准备终止的其他对象或类执行的可能操作，在执行该操作时，对象可能被丢弃。
* 对于任何指定对象java虚拟机只调用一次finalize()方法
* @throws Throwable the {@code Exception} raised by this method
*/
protected void finalize() throws Throwable { }
}
转载于:https://my.oschina.net/u/1760791/blog/759576
扫一扫
443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
