Object类分析equals、hashcode、clone

Object类中的equals：

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

可见equals方法就是比较引用是不是相同，感觉挺没用的一个方法。
所以String类覆盖为：

public boolean equals(Object anObject) {
	if (this == anObject) {
	    return true;
	}
	if (anObject instanceof String) {
	    String anotherString = (String)anObject;
	    int n = count;
	    if (n == anotherString.count) {
		char v1[] = value;
		char v2[] = anotherString.value;
		int i = offset;
		int j = anotherString.offset;
		while (n-- != 0) {
		    if (v1[i++] != v2[j++])
			return false;
		}
		return true;
	    }
	}
	return false;
    }

这个实现的意思是，如果两个字符串内容相同，就返回true。
这才是真正意义上的equals方法该做的事情。

---------------------------------------------------------------------------------
Object类中的hashcode()：

public native int hashCode();

这个本地方法返回的是该引用所指向的对象在内存中的地址。

public class Test{
	public static void main(String[] args){
		Person p = new Person();
		Person pp = p;
		Student s = new Student();

		System.out.println(""+p.hashCode());
		System.out.println(""+pp.hashCode());
                System.out.println(""+s.hashCode());
	}
}

结果为：

33263331
33263331
6413875

hashcode()和equals()肯定是对应的，可以试一下：

if(p.equals(pp)){
			System.out.println("equals true");
		}

		if(p == pp){
			System.out.println("== true");
		}

会显示：

equals true
== true

那么对于String来说，hashcode()肯定就是与内容相关的喽：

public int hashCode() {
	int h = hash;
        int len = count;
	if (h == 0 && len > 0) {
	    int off = offset;
	    char val[] = value;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }

---------------------------------------------------------------------------------
Object类中的clone()：

protected native Object clone() throws CloneNotSupportedException;

注意这个方法是protected，对于具体的类，要想实现拷贝，需要让这个类实现Cloneable接口，实现clone()方法。
这个方法是本地方法，实现的是浅复制。
如果只想进行浅复制，那么直接调用Object的clone()即可：

    class User {  
        String name;  
        int age;  
    }  

    class Account implements Cloneable {  
        User user;  
        long balance;  

        @Override  
        public Object clone() throws CloneNotSupportedException {  
            return super.clone();  
        }  
    }  

如果想进行深复制，那么需要修改clone()：

    class User implements Cloneable {  
        String name;  
        int age;  

        @Override  
        public User clone() throws CloneNotSupportedException {  
            return (User) super.clone();  
        }  
    }  

    class Account implements Cloneable {  
        User user;  
        long balance;  

        @Override  
        public Account clone() throws CloneNotSupportedException {  
            Account account = null;  

            account = (Account) super.clone();  
            if (user != null) {  
                account.user = user.clone();  
            }  

            return account;  
        }  
    }  

clone三部曲。
1 声明实现Cloneable接口。
2 调用super.clone拿到一个对象，如果父类的clone实现没有问题的话，在该对象的内存存储中，所有父类定义的field都已经clone好了，该类中的primitive和不可变类型引用也克隆好了，可变类型引用都是浅copy。
3 把浅copy的引用指向原型对象新的克隆体。