Java - Obejct 类 （待续）

关于object类中的方法，根据其所涉及的知识点，分为如下4个部分：

• 基础
  • clone : protected object clone() throws clonenotsupportedexception
  • equals : public boolean equals​(object obj)
  • hashcode : public int hashcode()
  • tostring : public string tostring()
• 反射
  
  • getclass : public final class<?> getclass()
• 线程
  • wait
    • public final void wait() throws interruptedexception
    • public final void wait​(long timeout) throws interruptedexception
    • public final void wait​(long timeout,int nanos) throws interruptedexception
  • notify : public final void notify()
  • notifyall : public final void notifyall()
• jvm
  • finalize : protected void finalize() throws throwable

---

 2018-09-15

今天写：equals、hashcode、tostring、clone、getclass，后面的方法等学到相关知识再作补充。

 一. equals

public boolean equals(object obj) {
    return (this == obj);
}

equals用来判断两个对象是否”相等“，而对“相等”这个词的定义不同，得出的结果也不同：

• 1. object类中的equals使用 this == obj 来定义相等，即：两个引用是否指向同一个对象；
• 2. 有些时候，我们并不需要定义如此严格的相等，比如：定义一个point类，只要两个点的横纵坐标分别相等，我们就认为它们相等；

要实现上面的需求，我们就需要重写equals方法，如下：

public class point {
    int x;
    int y;
    
    point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @override
    public boolean equals(object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof point) {
            point p = (point)obj;
            return (this.x == p.x && this.y == p.y);
        }
        return false;
    }
}

测试：

public static void main(string[] args) {
    point p1 = new point(1, 1);
    point p2 = new point(1, 1);
    system.out.println("p1.equals(p2) : " + p1.equals(p2));
    p2.x = 2;
    system.out.println("p1.equals(p2) : " + p1.equals(p2));
}
/* 输出
p1.equals(p2) : true
p1.equals(p2) : false
*/

另记：string类也重写了equals方法，实现了：只要两个字符串长度相等及字符串中对应位置的字符相等，则两字符串相等。可以参考string类中的equals方法。

注意：在重写equals方法时，方法定义要写为：public boolean equals(object obj) {....} ，参数类型是：object obj

 二. hashcode

public native int hashcode();

hashcode，官方解释：返回对象的一个哈希码，为基于哈希表的数据结构提供便利，如：hashmap等。

object类中的hashcode方法为本地方法，在重写hashcode方法时，需遵循以下规则：

• 1. 在对象equals比较中使用的信息未被修改的前提下，在java程序运行期间，同一个对象多次调用（不同时间）应该始终返回同一个整数。在程序不同的运行期间，返回的整数不需要保持一致；
• 2. 如果两个对象调用 equals(object obj) 时相等，那么这两个对象在调用 hashcode 时应该返回同一个整数值；
• 3. 并不要求为调用 equals(object obj) 时不相等的两个对象，返回两个不同的哈希码。只不过为不相等的对象返回不同的哈希码可以提高哈希表的性能；

关于第2条规则，我们继续point类这个例子。首先，在未重写hashcode方法的情况下，我们测试两个对象的hashcode()输出值：

public static void main(string[] args) {
    point p1 = new point(9483, 89382);
    point p2 = new point(9483, 89382);
    system.out.println("p1.hashcode() : " + p1.hashcode());
    system.out.println("p2.hashcode() : " + p2.hashcode());
}
/* 输出：
p1.hashcode() : 166239592
p2.hashcode() : 991505714
*/

可以看到，在我们定义的equals方法下相等的两个对象，得到的hashcode是不同的，如此不一致会造成什么后果呢？我们知道 hashmap 在存储<key, value>时，如果key1等于key2，那么存储的键值对为：<key1, value2>，即：只会存储一个key，使用的是最新的value。而 hashmap 中在判断 key1是否等于key2时，使用的就是它们的hashcode。在未重写hashcode方法的情况下，看如下测试：

public static void main(string[] args) {
    point p1 = new point(9483, 89382);
    point p2 = new point(9483, 89382);
    
    hashmap<point, integer> map = new hashmap<point, integer>();
    map.put(p1, p1.hashcode());
    map.put(p2, p2.hashcode());
    for (map.entry<point, integer> m : map.entryset()) {
        system.out.println(m);
    }
}
/* 输出
point@9e89d68=166239592
point@3b192d32=991505714
*/

根据我们对point类相等的定义，p1与p2相等，而在 hashmap 中却存入了两个键值对，显然不符合我们的意图。（equals与hashcode的不一致，会造成使用时产生歧义，从而导致意想不到的错误。所以，我们在重写equals方法后，也要重写hashcode方法，使其意义一致）现在我们来重写hashcode方法，再进行如上测试：

@override
public int hashcode() {
    return (x & y) | (x ^ y);
}
/* 输出
point@17d2f=97583
*/

根据我们对hashcode方法的定义，对象的hashcode只与(x, y)相关，所以 p1.hashcode() == p2.hashcode() 为 true。这样一来，hashmap 中只会存入一个键值对，符合我们的预期。

 三. tostring

public string tostring() {
    return getclass().getname() + "@" + integer.tohexstring(hashcode());
}

源码中直接返回：对象类型名@对象hashcode的十六进制，举个例子：

public static void main(string[] args) {
    point p1 = new point(9483, 89382);
    system.out.println(p1.tostring());
}
/* 输出
point@17d2f
*/

很多情况下，我们都要重写tostring()方法，就比如point类，我们想知道的是点的横纵坐标(x, y)，而不是 point@17d2f 这串不知所云的字符。

@override
public string tostring() {
    return "(" + x + ", " + y + ")";
}
/* 输出
(9483, 89382)
*/

四. clone

protected native object clone() throws clonenotsupportedexception;

 从方法定义入手：

• 1. protected，表明只有本类及其子类可以使用该方法来克隆对象，子类可以重写该方法；
• 2. native，表明object类中clone是本地方法；
• 3. clonenotsupportedexception，如果调用clone方法的对象的类没有 implememnts cloneable，就会抛出这个异常；

现在，我们对之前的point类进行部分修改，为了节省空间，我只贴出修改部分的代码：

首先，定义data类，用来记录一个点所包含的相关信息；

public class data {
    int weight;
    string name;
    
    data(int weight, string name) {
        this.weight = weight;
        this.name = name;
    }
}

然后，point类实现cloneable接口，并且point类中包含一个data类型字段，如下：

public class point implements cloneable {
    int x;
    int y;
    data data;

    point(int x, int y, data data) {
        this.x = x;
        this.y = y;
        this.data = data;
    }
    ...
}

测试：

public static void main(string[] args) throws exception {
    data data = new data(20, "a");
    point p1 = new point(1, 2, data);
    point p2 = (point)p1.clone();
    
    system.out.println("p1 == p2 : " + (p1 == p2));
    system.out.println("p1.(x, y) = " + p1.tostring() + ", p2.(x, y) = " + p2.tostring());
    system.out.println("p1.data == p2.data : " + (p1.data == p2.data));
}
/* 输出
p1 == p2 : false
p1.(x, y) = (1, 2), p2.(x, y) = (1, 2)
p1.data == p2.data : true
*/

对于测试的输出，我们可以发现：

• 1. p1 == p2 为 false，说明 p1.clone() 重新生成了一个对象；
• 2. p1.(x, y) 等于 p2.(x, y)，说明 p1.clone() 会把原对象的基础数据类型字段的值拷贝给生成的新对象的对应字段；
• 3. p1.data == p2.data 为 true，说明引用类型字段，新对象的字段与原对象的字段引用同一个对象；

对于第3条，即object类的clone方法是浅拷贝，理解如图：

 

在一些并发编程情景下，我们常常需要操作 不可变对象 来保证并发安全性。不可变对象，顾名思义就是你创建的对象不会改变，你可以理解为：

• 1. 对象本身就是不可变的，如：字段都是final修饰等；
• 2. 对象本身可变，但是我们确保在使用的时候不会去改变它，即人为的不可变；

（更详细的内容，可以参考《java并发编程实战》）

现在，假如我要在并发环境下使用p1.clone()出来的对象p2，并要求p2是不可变的。而事实上，其他线程可以通过 p1.data 来改变 p2.data 的状态，以破坏p2的不可变性。

要想使p2不可变，我们就需要对point类进行深拷贝，即：对piont类中的data类型字段也创建一个新的对象，使得 p1.data != p2.data，如下：

public class data {
    ...
    // 自定义的clone()，并非重写object类中的clone()
    public data clone() {
        return new data(weight, name);
    }
}
public class point implements cloneable {
    ...
    @override
    protected object clone() throws clonenotsupportedexception {
        point p = (point)super.clone();
        p.data = data.clone(); // 这里的data.clone()与object类中的clone()无关
        return p;
    }
    ...
}
/* 重复上面的测试，输出：
p1 == p2 : false
p1.(x, y) = (1, 2), p2.(x, y) = (1, 2)
p1.data == p2.data : false
*/

思考：如果一个类中一直嵌套着包含引用类型字段，那么我们该怎么才能做到深拷贝呢？很明显，对于类中每一个引用类型对象都做深拷贝。（递归处理）

 五. getclass

public final native class<?> getclass();

getclass方法，返回对象的类对象，在反射中经常使用，例如：

data类中有个私有方法 printinfo()，该方法在point类中无法正常调用，但是我们可以通过反射机制来调用该方法。

public class data {
    ...
    private void printinfo() {
        system.out.println("weight = " + weight);
        system.out.println("name : " + name);
    }
}
// 在point类中
public static void main(string[] args) throws exception {
    data data = new data(20, "a");
    class<?> clz = data.getclass();
    method m = clz.getdeclaredmethod("printinfo");
    m.setaccessible(true); // 抑制java的访问控制检查
    m.invoke(data);
}
/* 输出
weight = 20
name : a
*/

这里只是简单提一下，更多关于反射的知识，会在后期总结。