Java 父类Object类的常用方法总结

 

Object类： 是所有类默认继承的父类。

Object类的方法：

 

 

Object类有12个成员方法，按照用途可以分为以下几种：
1）构造函数 
2）hashCode和equals函数用来判断对象是否相同, 
3）wait(),wait(long),wait(long,int),notify(),notifyAll() 
4）toString()和getClass()
5）clone() 
6）finalize()用于在垃圾回收

 

getClass方法

可以返回这个实体的Class对象，可以用来获得这个类的元数据。在反射中经常使用。

clone方法

被用来拷贝一个新对象。在Java中使用等号只是拷贝对象的引用并不是对象，需要拷贝对象的时候，可以借助clone方法。

要通过clone方法复制某一个对象，在该类中必须实现java.lang.Cloneable接口。 下面的代码将演示浅拷贝。

public class Province {
    private String name;
    Province(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class Student implements Cloneable {

    private String name;
    private int age;
    private Province province;

    public Student(int age, String name, Province province){
        this.age = age;
        this.name = name;
        this.province = province;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    protected Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void main(String[] args) {
        Province teacher = new Province("Shannxi");
        Student student1 = new Student(23, "mianjingxiangjie", teacher);
        Student student2 = (Student) student1.clone();
        student1.province.setName("Beijing");
        System.out.println(student1.province.getName());
        System.out.println(student2.province.getName());
    }
}

上面的代码输出如下：

Beijing
Beijing

 

可见当实现Cloneable 接口的对象有其他对象的成员变量时，clone方法并不会复制一个新的成员变量。上面的student1和student2使用的是同一个province对象，当更改了student1的province名称，student2的province也相应的改变了。这就是浅拷贝。 那么怎么实现深拷贝呢？ 以上面的例子为例只需要改变clone方法如下：

@Override
    protected Object clone(){
        try {
            Student temp =  (Student) super.clone();
            temp.province = new Province(province.getName());
            return temp;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

在这段代码中需要手动创建一个新的province对象，也就是我们在clone方法里面需要将成员变量的对象进行手动拷贝就可以达到深拷贝的目的。

 

toString方法

toString提供对象的字符串表示形式。 类Object的默认toString（）方法返回一个字符串，该字符串包括该对象的类名称，"@"字符以及该对象的哈希码的无符号十六进制表示形式。 当需要打印对象引用时，toString方法就会被调用。

public class Student {

    private String name;

    private int age;

    public Student(int age, String name){
        this.age = age;
        this.name = name;
    }

    public static void main(String[] args) {
        Student student = new Student(23, "mianjingxiangjie");
        System.out.println(student.toString());
    }
}

打印出的结果是：

Student@4554617c

 

hashCode方法

对于每个对象，JVM都会生成一个唯一的数字，即哈希码。它为不同的对象返回不同的整数。 这个方法为HashMap、HashSet等方法提供支持。具体原因可以参考HashMap的讲解文章。 针对上面的toString方法的演示代码中，添加一个hashcode方法，指定对象的哈希码。

@Override
    public int hashCode() {
        return 200;
    }

打印的结果将为：

Student@c8

其中c8是16进制表示，转化为10进制就是12 * 16 + 8 = 200，正好是hashcode的返回值。

 

equals方法

被用来比较两个对象是否相等。在重写equals的时候也需要重写hashCode方法。 HashMap和Hashset中判断两个对象是否相等，首先比较hashCode，如果hashCode相等才回执行equals方法。

 

finalize方法

这个方法在垃圾回收之前被执行，可以通过重写finalize方法来重置系统资源，执行清理活动并且最大程度的减少内存泄露。 可以通过下面的实例来测试：

public class Student {

    private String name;

    private int age;

    public Student(int age, String name){
        this.age = age;
        this.name = name;
    }

    public void finalize(){
        System.out.println("对象被回收！");
    }

    public static void main(String[] args) {
        Student student = new Student(23, "mianjingxiangjie");
        System.out.println(student.toString());
        student = null;
        System.gc();
    }
}

上面的代码会输出如下结果：

Student@4554617c
对象被回收！

 

wait方法

调用线程放弃锁并且进入睡眠状态，直到其他线程进入同一个monitor并且执行notify唤醒线程。

notify，notifyAll 方法

和wait相反，用于唤醒线程。

 

Object的源码：

package java.lang;     
public class Object {     
      
   /* 一个本地方法，具体是用C（C++）在DLL中实现的，然后通过JNI调用。*/      
    private static native void registerNatives();     
  /* 对象初始化时自动调用此方法*/    
    static {     
        registerNatives();     
    }     
   /* 返回此 Object 的运行时类。*/    
    public final native Class<?> getClass();     
    
/*   
hashCode 的常规协定是：   
1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。    
2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。    
3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。   
*/    
    
    public native int hashCode();     
    
    
    public boolean equals(Object obj) {     
    return (this == obj);     
    }     
    
    /*本地CLONE方法，用于对象的复制。*/    
    protected native Object clone() throws CloneNotSupportedException;     
    
    /*返回该对象的字符串表示。非常重要的方法*/    
    public String toString() {     
    return getClass().getName() + "@" + Integer.toHexString(hashCode());     
    }     
    
   /*唤醒在此对象监视器上等待的单个线程。*/    
    public final native void notify();     
    
   /*唤醒在此对象监视器上等待的所有线程。*/    
    public final native void notifyAll();     
    
    
/*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。    
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/    
    public final void wait() throws InterruptedException {     
    wait(0);     
    }     
    
    
    
   /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。*/    
    public final native void wait(long timeout) throws InterruptedException;     
    
    /* 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。*/    
    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);     
    }     
    
    /*当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。*/    
    protected void finalize() throws Throwable { }     
}    

 

 

参考原文：

https://blog.csdn.net/Ryan_lee9410/article/details/80207772

https://www.cnblogs.com/1605-3QYL/p/12613472.html

https://www.cnblogs.com/langtianya/archive/2013/01/31/2886572.html