Java源码之Object类

最新推荐文章于 2024-02-20 11:32:36 发布

亚洲小炫风

最新推荐文章于 2024-02-20 11:32:36 发布

阅读量2.1k

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/axuanqq/article/details/79114542

版权

java 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

  // 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 表示对象的存储地址,但是如果重写了hash code 就不一定表示存储地址了)

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();
        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

亚洲小炫风

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录