Object

Java中的Object是所有类的父类，是“万类之源”

Class Object
java.lang.Object
public class Object
Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including arrays, implement the methods of this class.

我们把jdk安装路径目录下的src.rar文件解压，可以看到Object.java:
(为了页面大小，删除了大量的注释，读者自行查看）

点击(此处)折叠或打开

1. public class Object {
   
2. 
   
3.     private static native void registerNatives();
   
4.     static {
   
5.         registerNatives();
   
6.     }
   
7.     
   
8.     public boolean equals(Object obj) {
   
9.         return (this == obj);
   
10.     }
    
11.     
    
12.     protected native Object clone() throws CloneNotSupportedException;
    
13.     
    
14.     public String toString() {
    
15.         return getClass().getName() + "@" + Integer.toHexString(hashCode());
    
16.     }
    
17. 
    
18.     public final native void notify();
    
19. 
    
20.     public final native void notifyAll();
    
21.  
    
22.     public final native void wait(long timeout) throws InterruptedException;
    
23.   
    
24.     public final void wait(long timeout, int nanos) throws InterruptedException {
    
25.         if (timeout < 0) {
    
26.             throw new IllegalArgumentException("timeout value is negative");
    
27.         }
    
28. 
    
29.         if (nanos < 0 || nanos > 999999) {
    
30.             throw new IllegalArgumentException(
    
31.                                 "nanosecond timeout value out of range");
    
32.         }
    
33. 
    
34.         if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
    
35.             timeout++;
    
36.         }
    
37. 
    
38.         wait(timeout);
    
39.     }
    
40. 
    
41.     public final void wait() throws InterruptedException {
    
42.         wait(0);
    
43.     }
    
44.      
    
45.     protected void finalize() throws Throwable { }
    
46. }

仔细观察上面的各方法，很快就知道哪些方法可以被子类所继承，被finally,private修饰的方法已经被"写死"在父类中，子类不能继承修改，而static方法不具有多态特性。（java中除了被private，static，private修饰的方法是前期绑定，其他的方法都是后期绑定，这是题外话，这属于多态方面的知识）
查阅API文档，Object类中定义的方法： http://docs.oracle.com/javase/8/docs/api/index.html


其中可以被子类继承的方法是： clone ,  equals ,  finalize ,  getClass ,  hashCode ,  notify ,  notifyAll ,  toString ,  wait ,  wait ,  wait
具体的各个方法可以查阅API文档去了解。

点击(此处)折叠或打开

1. public class Name implements Cloneable {
   
2.   
   
3.     private String firstName,lastName;
   
4.     public Name(String firstName,String lastName){
   
5.         
   
6.         this.firstName = firstName;
   
7.         this.lastName = lastName;
   
8.     }
   
9.     public String getFirstName(){
   
10.         return firstName;
    
11.     }
    
12.     public String getLastName(){
    
13.         return lastName;
    
14.     }
    
15.     public String toString(){
    
16.         
    
17.         return firstName + " " + lastName;
    
18.     }
    
19.     
    
20.     public Object clone() throws CloneNotSupportedException {
    
21.      return (Name)super.clone();
    
22.     }
    
23.     
    
24.     public boolean equals(Object obj){
    
25.         
    
26.         if(obj instanceof Name){
    
27.             
    
28.             Name name = (Name)obj;
    
29.             return (firstName.equals(firstName))&&(lastName.equals(lastName));
    
30.         }
    
31.      return super.equals(obj);
    
32.     }
    
33.     public int hashCode(){
    
34.         
    
35.         return firstName.hashCode();
    
36.     }
    
37. }
    
38. 
    
39. public class Test{
    
40.    
    
41.     public static void main(String[] args){
    
42.         Name n = new Name("diy","os");
    
43.      try{
    
44.      Name m =(Name)n.clone();
    
45.      String ss = m.getFirstName() + m.getLastName();
    
46.      System.out.println(ss);
    
47.      System.out.println(m.equals(n));
    
48.      System.out.println(n.equals(m));
    
49.      System.out.println("m.hashCode:" + m.hashCode() + " " + "n.hashCode:" + n.hashCode());
    
50.      
    
51.      Name p = n;
    
52.      System.out.println("n.hashCode:" + n.hashCode() + " " + "p.hashCode:" + p.hashCode());
    
53.      System.out.println("p.hashCode" + p.hashCode() + " " + "m.hashCode" + m.hashCode());
    
54.      System.out.println(n.getClass());
55.      }catch(CloneNotSupportedException e){
    
56.          
    
57.          e.printStackTrace();
    
58.      }
    
59.      
    
60.  }
    
61. }

执行结果：


指出该方法可能抛出异常，则对这种异常，一定要进行捕获处理（对于把异常抛给调用者，但是最终还是被处理），上面重写了clone方法，并用public修饰，为了在Test类中可以调用。然后在Test类中捕获可能发生的异常，引用m是从n clone而来，所以equals为true，而且hashCode也相等，接着在栈里创建了Name引用p,n赋值给p,也就是两者指向同一堆内存，比较p,n的hashCode,是相同的！p,m的hashCode也是相同的！脑海里应该自然的浮现四块内存区域：栈中:m,n,p  堆中：new出的Name对象    m,p,n指针指向Name对象   
这里说明的是，hashCode并不是实际的物理地址！
getClass()返回的是当前运行的类对象
关于toString()方法，这里不再赘述，学习java的朋友，这个方法都应该很熟悉。
上面简单的介绍，也是自己一个小小的总结，关于深入的了解Object类，可以参考其他书籍，如果错误之处，请读者指正！