object java源码_Java源码之Object类

最新推荐文章于 2022-09-12 10:00:00 发布

来听大家讲故事

最新推荐文章于 2022-09-12 10:00:00 发布

阅读量353

点赞数

文章标签： object java源码

本文链接：https://blog.csdn.net/weixin_42297349/article/details/114441113

版权

// IntelliJ API Decompiler stub source generated from a class file

// Implementation of methods is not available

package java.lang;

public class Object {

public Object() { /* compiled code */ }

private static native void registerNatives();

public final native java.lang.Class> getClass();

public native int hashCode();

public boolean equals(java.lang.Object o) { /* compiled code */ }

protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException;

public java.lang.String toString() { /* compiled code */ }

public final native void notify();

public final native void notifyAll();

public final native void wait(long l) throws java.lang.InterruptedException;

public final void wait(long l, int i) throws java.lang.InterruptedException { /* compiled code */ }

public final void wait() throws java.lang.InterruptedException { /* compiled code */ }

protected void finalize() throws java.lang.Throwable { /* compiled code */ }

}

Object是java所有类的终极类,我们常见的自定义class 但是并没有继承Object(Java编译器自动引入,如果手动继承Object,也是没有问题的,java单继承有一定的局限)

public static class User {

@Override

protected Object clone() throws CloneNotSupportedException {

return super.clone();

}

@Override

public int hashCode() {

return super.hashCode();

}

Object类约12个方法,下面一一解释这些方法的作用

1. getClass()

public final Class> getClass() {

return shadow$_klass_;

}

返回此Object的运行时类

实际结果的类型是Class extends |X|>其中|X|是静态类型上其表达的擦除getClass被调用。例如，在此代码片段中不需要转换：

Number n = 0;

Class extends Number> c = n.getClass();

2. hashCode()

/* @return a hash code value for this object.

* @see java.lang.Object#equals(java.lang.Object)

* @see java.lang.System#identityHashCode

public int hashCode() {

return identityHashCode(this);

}

返回对象的hash值,支持这种方法是为了散列表,如hashmap

hashcode 的特点是:

1.只要在执行Java应用程序时多次在同一个对象上调用该方法,hashcode()始终返回相同的整数(前提是该对象的信息没有发生改变)

2.相对于两个对象来说,如果使用了equals方法比较返回true,那么这两个对象的hashcode值也是相同的

3. 对于两个对象来说,如果使用equals方法比较为false,那么这两个对象的hash值不一定要求不同,可以相同也可以不同,然而如果不同,则可以提高性能

4. 对于Object类来说,不同的Object对象的hashcode是不同的(Object的hashcode 表示对象的存储地址,但是如果重写了hashcode 就不一定表示存储地址了)

3. Clone()

protected Object clone() throws CloneNotSupportedException {

if (!(this instanceof Cloneable)) {

throw new CloneNotSupportedException("Class " + getClass().getName() +

" doesn't implement Cloneable");

}

return internalClone();

}

克隆方法:创建并返回此对象的副本;

对于任何对象x x.clone()!=x

而且x.clone().getClass()==x.getClass() 成立虽然对象的基类都支持clone 但是object本身并未实现cloneable,所以自定义的类需要实现cloneable接口,否则将抛出异常

4. toString()

返回对象的字符串表示形式,一般说来,这个方法返回一个固定的模版

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

这个在实际开发中,并不好体现,所以各大编译器都支持重新生成toString(),如:

public static class User {

private String name;

private int age;

@Override

public String toString() {

return "User{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

5. finalize()

/* @throws Throwable the {@code Exception} raised by this method

* @see java.lang.ref.WeakReference

* @see java.lang.ref.PhantomReference

* @jls 12.6 Finalization of Class Instances

protected void finalize() throws Throwable { }

finalize()方法可以被子类对象所覆盖，然后作为一个终结者，当GC被调用的时候完成最后的清理工作(例如释放系统资源之类)。这就是终止。默认的finalize()方法什么也不做，当被调用时直接返回。

对于任何一个对象，它的finalize()方法都不会被JVM执行两次。如果你想让一个对象能够被再次调用的话(例如，分配它的引用给一个静态变量)，注意当这个对象已经被GC回收的时候，finalize()方法不会被调用第二次。

测试:

package asange.javastudy.java.lang;

/**

* @author youxuan E-mail:xuanyouwu@163.com

* @version 2.3.1

* @Description

* @date createTime：2018/1/20

public class ObjectTest {

public static class User {

private String name;

private int age;

@Override

public String toString() {

return "User{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Override

protected void finalize() throws Throwable {

System.out.println("finalize");

super.finalize();

}

public static void main(String[] args) throws Exception {

User o = new User();

o = null;

System.gc();

}

运行结果:

asange.javastudy.java.lang.ObjectTest

finalize

Process finished with exit code 0

可以看到结果:两次gc finalize 只执行了一次

6. wait() notify() notifyAll()

这三个方法是有关线程阻塞与线程唤醒

1. wait(),notify()与notifyAll()方法是本地方法,并且是final类型,无法重写

2. 调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的monitor(即锁)

3. 调用某个对象的notify()方法能唤醒一个正在等待这个对象的monitor的线程,如果有多个线程在等待这个monitor,唤醒其中一个线程;

4. 调用notifyAll()方法能唤醒所有正在等待这个对象的monitor

为何这三个不是Thread类声明中的方法，而是Object类中声明的方法(当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法)？其实这个问题很简单，由于每个对象都拥有monitor(即锁)，所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。

上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor(即锁)，因此调用wait()方法必须在同步块或者同步方法中进行(synchronized块或者synchronized方法)。

调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁(Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁)；

notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。

同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行(synchronized块或者synchronized方法)。

nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。

这里要注意一点：notify()和notifyAll()方法只是唤醒等待该对象的monitor的线程，并不决定哪个线程能够获取到monitor。

举个简单的例子：假如有三个线程Thread1、Thread2和Thread3都在等待对象objectA的monitor，此时Thread4拥有对象objectA的monitor，当在Thread4中调用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一个能被唤醒。注意，被唤醒不等于立刻就获取了objectA的monitor。假若在Thread4中调用objectA.notifyAll()方法，则Thread1、Thread2和Thread3三个线程都会被唤醒，至于哪个线程接下来能够获取到objectA的monitor就具体依赖于操作系统的调度了。

上面尤其要注意一点，一个线程被唤醒不代表立即获取了对象的monitor，只有等调用完notify()或者notifyAll()并退出synchronized块，释放对象锁后，其余线程才可获得锁执行。

public class ObjectTest {

public static Object obj = new Object();

public static void main(String[] args) throws Exception {

Object o2 = new Object();

Thread1 thread1 = new Thread1();

Thread2 thread2 = new Thread2();

thread1.start();

thread2.start();

}

static class Thread1 extends Thread {

@Override

public void run() {

super.run();

System.out.println("线程" + Thread.currentThread().getName() + "开始");

synchronized (obj) {

try {

System.out.println("线程" + Thread.currentThread().getName() + "调用了object.wait()");

obj.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程" + Thread.currentThread().getName() + "获取到了锁");

}

static class Thread2 extends Thread {

@Override

public void run() {

super.run();

System.out.println("线程" + Thread.currentThread().getName() + "开始");

synchronized (obj) {

obj.notify();

System.out.println("线程" + Thread.currentThread().getName() + "调用了object.notify()");

}

System.out.println("线程" + Thread.currentThread().getName() + "释放了锁");

}

运行结果:

线程Thread-0开始

线程Thread-1开始

线程Thread-0调用了object.wait()

线程Thread-1调用了object.notify()

线程Thread-1释放了锁

线程Thread-0获取到了锁

Process finished with exit code 0

来听大家讲故事

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
object java源码_Java源码之Object类

// IntelliJ API Decompiler stub source generated from a class file// Implementation of methods is not availablepackage java.lang;public class Object {public Object() { /* compiled code */ }private sta...
复制链接

扫一扫