Java源码之Object

本文出自：http://blog.csdn.net/dt235201314/article/details/78318399

一丶概述

JAVA中所有的类都继承自Object类，就从Object作为源码解析的开始。

二丶常见方法

注： 以上绿色方法为 非native方法  粉色方法为 native方法）

什么是native方法？

native关键字标识的java方法为本地方法，底层是有c/c++编写的程序编译后dll文件，java加载dll文件后，可用通过本地方法调用dll中函数，如有疑问可用参考JNI使用方式。

什么是JNI方法？

向东是底层，向西是应用，咱们先一路向西。向东参考：JNI方法使用

1.Object():默认构造函数（源码无系统默认提供）

2.void registerNatives()

[java] view plain copy
 
  1. /* 一个本地方法，具体是用C（C++）在DLL中实现的，然后通过JNI调用。*/        
  2.     private static native void registerNatives();       
  3.   /* 对象初始化时自动调用此方法*/      
  4.     static {       
  5.         registerNatives();       
  6.     }    

3.final getClass()

[java] view plain copy
 
  1. /* 返回此 Object 的运行时类。*/      
  2.     public final native Class<?> getClass();   

例：

[java] view plain copy
 
  1. public class tests  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         A te = new B();  
  6.         System.out.println(te.getClass());  
  7.     }  
  8. }  
  9. class A{  
  10.   
  11. }  
  12. class B extends A  
  13. {  
  14.   
  15. }  


运行结果：class B

A类的引用，但是运行时te这个对象的实际类是B。

4.int hashCode()方法

[java] view plain copy
 
  1. /*    
  2. hashCode 的常规协定是：    
  3. 1.在应用程序执行期间，如果一个对象用于equals()方法的属性没有被修改的话， 
  4. 那么要保证对该对象多次返回的hashcode值要相等。 
  5. 2.如果2个对象通过equals()方法判断的结果为true，那么要保证二者的hashcode值相等。 
  6. 3.如果2个对象通过equals()方法判断的结果为false，那么对二者hashcode值是否相等并没有明确要求。 
  7. 如果不相等，那么能够提升散列表的性能。    
  8. */      
  9.       
  10.     public native int hashCode();  

实际计算方法：

[java] view plain copy
 
  1. public int hashCode() {  
  2.         int h = hash;  
  3.         if (h == 0 && value.length > 0) {  
  4.             char val[] = value;  
  5.             for (int i = 0; i < value.length; i++) {  
  6.                  h = 31 * h + val[i];  
  7.              }  
  8.             hash = h;    
  9.        }  
  10.          return h;  
  11.      }  

5.boolean equals(Object obj)

[java] view plain copy
 
  1. public boolean equals(Object obj) {       
  2.     return (this == obj);       
  3.     }   


从这里我们可以看到，equals（obj）方法最根本的实现就是‘==’，因此对于一些自定义类，如果没有重写hashcode（）方法和equals（）方法的话，利用‘==’和equals()方法比较的结果是一样的。对于‘==’比较的是地址，equals()方法比较的是内容这种说法，是片面的。（虽然在最常用的String类中是这样的）。

equal方法常被重写

例：String（先比较String对象内存地址相同，若相同则返回true，否则判断String对象对应字符的内容是否相等，若相等则返回true）

[java] view plain copy
 
  1. public boolean equals(Object anObject) {  
  2.          if (this == anObject) {  
  3.              return true;  
  4.          }  
  5.          if (anObject instanceof String) {  
  6.              String anotherString = (String)anObject;  
  7.              int n = value.length;  
  8.              if (n == anotherString.value.length) {  
  9.                  char v1[] = value;  
  10.                  char v2[] = anotherString.value;  
  11.                  int i = 0;  
  12.                  while (n-- != 0) {  
  13.                      if (v1[i] != v2[i])  
  14.                          return false;  
  15.                      i++;  
  16.                  }  
  17.                  return true;  
  18.              }  
  19.          }  
  20.          return false;  
  21.      }  

6.clone()

[java] view plain copy
 
  1. /*本地CLONE方法，用于对象的复制。*/      
  2.     protected native Object clone() throws CloneNotSupportedException;  

一起看下native方法 位于openjdkhotspotsrcsharevmprimsjvm.cpp中 JVM_Clone的实现  片段

[java] view plain copy
 
  1. JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))  
  2.   JVMWrapper("JVM_Clone");  
  3.   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));  
  4.   const KlassHandle klass (THREAD, obj->klass());  
  5.   JvmtiVMObjectAllocEventCollector oam;  
  6.   
  7. #ifdef ASSERT  
  8.   // Just checking that the cloneable flag is set correct  
  9.   if (obj->is_javaArray()) {  
  10.     guarantee(klass->is_cloneable(), "all arrays are cloneable");  
  11.   } else {  
  12.     guarantee(obj->is_instance(), "should be instanceOop");  
  13.     bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());  
  14.     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");  
  15.   }  
  16. #endif  
  17.   
  18.   // Check if class of obj supports the Cloneable interface.  
  19.   // All arrays are considered to be cloneable (See JLS 20.1.5)  
  20.   if (!klass->is_cloneable()) {  
  21.     ResourceMark rm(THREAD);  
  22.     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());  
  23.   }  
  24.   
  25.   // Make shallow object copy  
  26.   const int size = obj->size();  
  27.   oop new_obj = NULL;  
  28.   if (obj->is_javaArray()) {  
  29.     const int length = ((arrayOop)obj())->length();  
  30.     new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);  
  31.   } else {  
  32.     new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);  
  33.   }  
  34.   // 4839641 (4840070): We must do an oop-atomic copy, because if another thread  
  35.   // is modifying a reference field in the clonee, a non-oop-atomic copy might  
  36.   // be suspended in the middle of copying the pointer and end up with parts  
  37.   // of two different pointers in the field.  Subsequent dereferences will crash.  
  38.   // 4846409: an oop-copy of objects with long or double fields or arrays of same  
  39.   // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead  
  40.   // of oops.  We know objects are aligned on a minimum of an jlong boundary.  
  41.   // The same is true of StubRoutines::object_copy and the various oop_copy  
  42.   // variants, and of the code generated by the inline_native_clone intrinsic.  
  43.   assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");  
  44.   Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,  
  45.                                (size_t)align_object_size(size) / HeapWordsPerLong);  
  46.   // Clear the header  
  47.   new_obj->init_mark();  
  48.   
  49.   // Store check (mark entire object and let gc sort it out)  
  50.   BarrierSet* bs = Universe::heap()->barrier_set();  
  51.   assert(bs->has_write_region_opt(), "Barrier set does not have write_region");  
  52.   bs->write_region(MemRegion((HeapWord*)new_obj, size));  
  53.   
  54.   // Caution: this involves a java upcall, so the clone should be  
  55.   // "gc-robust" by this stage.  
  56.   if (klass->has_finalizer()) {  
  57.     assert(obj->is_instance(), "should be instanceOop");  
  58.     new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);  
  59.   }  
  60.   
  61.   return JNIHandles::make_local(env, oop(new_obj));  
  62. JVM_END  

看不懂，这里参考大神讲解

隐含意思：数组类型默认可以直接克隆，而其他对象实现clone需要先实现Cloneable接口，否则抛出CloneNotSupportedException异常
问题1：对象的创建有多中方式，类似 new 、getInstance、clone等 clone有什么好处？
问题2：对象调用clone方法生成的对象 和 原对象是否还有什么关联关系？
问题3 : 对象clone存在 “浅复制”、“深复制”概念，怎么区分？
带着这3个问题，理解Object clone方法：
1、一般native方法比java中非native方法执行效率高 ，看示例

[java] view plain copy
 
  1. public class ObjectCloneTest1 {  
  2.      static final int N = 100000;  
  3.      public static void main(String[] args) {  
  4.          final Date date = new Date();  
  5.          {   
  6.              final long startTime = System.currentTimeMillis();  
  7.              for (int i = 0; i < N; i++) {  
  8.                  Date date2 = (Date) date.clone();  
  9.              }  
  10.              final long endTime = System.currentTimeMillis();   
  11.              System.out.println("clone:" + (endTime - startTime) + "ms");  
  12.          }   
  13.          {  
  14.              final long startTime = System.currentTimeMillis();  
  15.              for (int i = 0; i < N; i++) {  
  16.                  final Calendar cal = Calendar.getInstance();  
  17.                  cal.setTime(date);  
  18.                  final Date date2 = cal.getTime();  
  19.              }  
  20.    
  21.              final long endTime = System.currentTimeMillis();  
  22.              System.out.println("Calender.setTime:" + (endTime - startTime) + "ms");  
  23.    
  24.          }  
  25.    
  26.      }  
  27.    
  28.  }  



2、clone生成的新对象与原对象的关系，需要区别2个对象建是否存在相同的引用或对应的内存地址是否存在共用情况，若存在则 该次clone为 “浅复制”，否则为“深复制”, 而且Object的clone方法是属于 “浅复制”，看示例

[java] view plain copy
 
  1. public class ObjectCloneTest2 {   
  2.      public static void main(String[] args) {  
  3.          Animal a1 = new Animal(1, "pig");  
  4.          Animal a2 = (Animal) a1.clone();  
  5.          System.out.println(a1.getName() == a2.getName() ? "浅复制" : "深复制");  
  6.            
  7.          System.out.println(a1);  
  8.          a1.setAge(11);  
  9.          a1.setName("big pig");  
  10.          System.out.println(a1.age + ":" + a1.name);  
  11.            
  12.          System.out.println(a2);  
  13.          System.out.println(a2.age + ":" + a2.name);  
  14.            
  15.      }  
  16.    
  17.  }  
  18.    
  19.  class Animal implements Cloneable{  
  20.      int age;  
  21.      String name;  
  22.    
  23.      Animal(int age, String name) {  
  24.          this.age = age;  
  25.          this.name = name;  
  26.      }  
  27.    
  28.      public Animal clone() {  
  29.          Animal o = null;  
  30.    
  31.          try {  
  32.              o = (Animal) super.clone();  
  33.          } catch (CloneNotSupportedException e) {  
  34.              e.printStackTrace();  
  35.          }  
  36.    
  37.          return o;  
  38.      }  
  39.    
  40.      public int getAge() {  
  41.          return age;  
  42.      }  
  43.    
  44.      public void setAge(int age) {  
  45.          this.age = age;  
  46.      }  
  47.    
  48.      public String getName() {  
  49.          return name;  
  50.      }  
  51.      public void setName(String name) {  
  52.          this.name = name;  
  53.      }  
  54. }  


"深复制"时，需要将共同关联的引用也复制完全看示例

[java] view plain copy
 
  1. public class ObjectCloneTest3 {  
  2.    
  3.      public static void main(String[] args) {  
  4.          Person p1 = new Person(10, "ll", new Race("yellow", "Asia"));  
  5.          Person p2 = (Person) p1.clone();  
  6.          System.out.println(p1.getRace() == p2.getRace());  
  7.          System.out.println(p1.getTestArray() == p2.getTestArray());  
  8.    
  9.      }  
  10.    
  11.  }  
  12.    
  13.  class Person implements Cloneable {  
  14.      int age;  
  15.      String name;  
  16.      Race race;  
  17.      int[] testArray = { 1, 23, 5, 6, 0 };  
  18.    
  19.      Person(int age, String name, Race race) {  
  20.          this.age = age;  
  21.          this.name = name;  
  22.          this.race = race;  
  23.      }  
  24.    
  25.      public Person clone() {  
  26.          Person o = null;  
  27.    
  28.          try {  
  29.              o = (Person) super.clone();  
  30.              o.setRace(this.race.clone());  
  31.              o.setTestArray(testArray.clone());  
  32.          } catch (CloneNotSupportedException e) {  
  33.              e.printStackTrace();  
  34.          }  
  35.    
  36.          return o;  
  37.      }  
  38.    
  39.       
  40.      public int getAge() {  
  41.          return age;  
  42.      }  
  43.    
  44.      public void setAge(int age) {  
  45.          this.age = age;  
  46.      }  
  47.    
  48.      public String getName() {  
  49.          return name;  
  50.      }  
  51.    
  52.      public void setName(String name) {  
  53.          this.name = name;  
  54.      }  
  55.    
  56.      public Race getRace() {  
  57.          return race;  
  58.      }  
  59.    
  60.      public void setRace(Race race) {  
  61.          this.race = race;  
  62.      }  
  63.        
  64.      public void setTestArray(int[] testArray) {  
  65.          this.testArray = testArray;  
  66.      }  
  67.    
  68.      public int[] getTestArray() {  
  69.          return testArray;  
  70.      }      
  71.    
  72. }  
  73.    
  74.  class Race implements Cloneable {  
  75.      String color; // 颜色  
  76.      String distribution; // 分布  
  77.    
  78.      public Race(String color, String distribution) {  
  79.          super();  
  80.          this.color = color;  
  81.          this.distribution = distribution;  
  82.      }  
  83.    
  84.      public Race clone() throws CloneNotSupportedException {  
  85.          return (Race) super.clone();  
  86.      }  
  87.  }  


false

false

7.toString()

[java] view plain copy
 
  1. /*返回该对象的字符串表示。非常重要的方法*/      
  2.     public String toString() {       
  3.     return getClass().getName() + "@" + Integer.toHexString(hashCode());       
  4.     }   

默认返回对象的名称及引用地址，但一般被子类重写用于说明子类相关属性值描述

8.final notify()

[java] view plain copy
 
  1. /*不能被重写，唤醒在此对象监视器上等待的单个线程。*/      
  2.  public final native void notify();  

9.final notifyAll()

[java] view plain copy
 
  1. /*唤醒在此对象监视器上等待的所有线程。*/      
  2.     public final native void notifyAll();  

10.final  void wait()方法

[java] view plain copy
 
  1. /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。     
  2. 当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/      
  3.     public final void wait() throws InterruptedException {       
  4.     wait(0);       
  5.     }  

11.final native void wait(long timeout)

[java] view plain copy
 
  1. /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。*/      
  2.    public final native void wait(long timeout) throws InterruptedException;  

该方法使当前线程等待，直到另外一个线程调用该对象的notify或notifyAll方法，或者等待时间已到，当前线程才会从等待池移到运行池。 
如果在wait之前或者wait的时候，当前线程被中断了，那么直到该线程被恢复的时候才会抛出中断异常（InterruptedException）

12.final void wait(long timeout,int nanos)

[java] view plain copy
 
  1. /* 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。*/  
  2. public final void wait(long timeout, int nanos) throws InterruptedException {  
  3.         if (timeout < 0) {  
  4.             throw new IllegalArgumentException("timeout value is negative");  
  5.         }  
  6.   
  7.         if (nanos < 0 || nanos > 999999) {  
  8.             throw new IllegalArgumentException(  
  9.                                 "nanosecond timeout value out of range");  
  10.         }  
  11.   
  12.         if (nanos > 0) {  
  13.             timeout++;  
  14.         }  
  15.   
  16.         wait(timeout);  
  17.     }  

 

13.protected void finalize()

[java] view plain copy
 
  1. /*当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。*/      
  2.    protected void finalize() throws Throwable { }  

垃圾回收器在认为该对象是垃圾对象的时候会调用该方法。子类可以通过重写该方法来达到资源释放的目的。 
在方法调用过程中出现的异常会被忽略且方法调用会被终止。 
任何对象的该方法只会被调用一次。  

三丶参看文章
Object类源码解析
【java基础之jdk源码】Object

四丶相关面试题

【码农每日一题】Java equals 与 hashCode 相关面试题

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/uu5666/p/7779276.html