Object类

Object是所有类的父类，它有很多类对象会用到的方法，例如比较常用的toString 、equals，当你新建xx类时，你可以重写Object已经定义的方法，也可以直接调用Object中的方法，如果你写一个封装的方法，不确定传进来的是什么类型的值，就可以使用Object作为一个笼统类。
我们可以显示的继承它，也可以隐式继承，如以下实例：

public class Dog extends Object{

}
//**************************************************************
public class Dog{

}

完全等价。

Object中包含的常用方法：

1. equals(Object obj)
2. finalize()
3. getClass
4. hashCode()
5. notify
6. notifyAll();
7. wait()
8. Clone()
9. toString()

“equals”和“==”的区别：

“==”是判断相等，equals也是判断相等，但是”==”主要用于判断基本数据类型的相等性，当然也可以直接判断两个对象。而equals主要判断对象内容。
实例：“==”判断基本数据类型

public static void main(String[] args) {

       int i = 1;

       int j = 1;

       boolean flag0 = true;
       boolean flag1 = false;

       System.out.println("i==j:"+(i==j));

       System.out.println("flag0==flag1:"+(flag0==flag1));

    }

运行结果：
i==j:true
flag0==flag1:false

实例：对象比较（equals）

public static void main(String[] args) {

       Dog dog0 = new Dog();

       Dog dog1 = new Dog();

       System.out.println(("dog0==dog1:")+(dog0==dog1));


    }

运行结果：
dog0==dog1:false

以上实例中的“==”，比较的是dog0的内存首地址和dog1 的内存首地址，由于dog0和dog1所指向的对象是在内存中开辟的两个空间，所以首地址是不一样的，此处打印输出false.

函数toString()：

toString()方法就是把对象转换成String类型，当我们直接打印某个对象引用的时候，该方法就会得到调用。

class Person {
    private String name = null;
    private int age = 0;
    public Person(String name, int age) {
         this.name = name;
         this.age  = age;
    }
    public String toString() {
         return "姓名："+name+"年龄："+age;
    }
}

public class Test {
    public static void main(String[] args) {
         Person p = new Person("Jack", 20);
         System.out.println(p.toString());// 这时会输出"Jack".
    }
}

输出结果是：
姓名：Jack年龄：20

经测试toString()方法主要是将内存中的具体内容输出，如果不调用toString()方法输出的是内容所在的地址Person@1db9742。

实例：

   class Person {
    private String name = null;
    private int age = 0;
    public Person(String name, int age) {
         this.name = name;
         this.age  = age;
    }
    public String Jave() {                  //将上面代码中的toString()方法名换成Jave
         return "姓名："+name+"年龄："+age;
    }
}

public class Test {
    public static void main(String[] args) {
         Person p = new Person("Jack", 20);
         System.out.println(p.toString());// 这时会输出"Jack".
    }
}

输出结果：
Person@1db9742

此时便输出内存地址，而不是内存中的内容

equals()方法

时常和hashCode 结合使用，主要是比较对象内容，但是在默认情况下，比较的是内存首地址。

public class EqualsDemo {

    public static void main(String[] args) {

       Dog dog0 = new Dog();

       Dog dog1 = new Dog();

       System.out.println(("dog0.equals(dog1):")+dog0.equals(dog1));
    }

}

运行结果：
dog0.equals(dog1):false
此时比较的是内存的首地址由于new了两次，那么创建两次栈内存空间，而内存的首地址不同，所以比较结果为false。

hashcode()方法:

hashcode这个方法是用来鉴定2个对象是否相等的。 那你会说，不是还有equals这个方法吗？ 不错，这2个方法都是用来判断2个对象是否相等的。但是他们是有区别的。 一般来讲，equals这个方法是给用户调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等 了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。

举个例子，有个学生类，属性只有姓名和性别，那么我们可以 认为只要姓名和性别相等，那么就说这2个对象是相等的。 hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode 这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相 当于是一个对象的编码，就好像文件中的md5，他和equals不同就在于他返回的是int型的，比较起来不直观。我们一般在覆盖equals的同时也要 覆盖hashcode，让他们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名 的hashcode值加上性别的hashcode值，这样从逻辑上，他们就一致了。 要从物理上判断2个对象是否相等，用==就可以了。

public class Dog {

    private String dogName;

    public String getDogName() {
       return dogName;
    }

    public void setDogName(String dogName) {
       this.dogName = dogName;
    }

    public int hashCode() {
       final int prime = 31;
       int result = 1;
        result = prime * result + ((dogName == null) ? 0 : dogName.hashCode());
       return result;
    }


    public boolean equals(Object obj) {
       if (obj == null)       
           return false;

       final Dog other = (Dog) obj;

        if (dogName.equals(other.dogName)){
         return true;
        }else{
        return false;
        }
    }

}

public static void main(String args[]){

       Dog dog0 = new Dog();

       dog0.setDogName("xiaobai");
       Dog dog1 = new Dog();
       dog1.setDogName("xiaobai");

       System.out.println("dog0.equals(dog1):"+dog0.equals(dog1));

    }

程序运行结果：
dog0.equals(dog1):true

可以通过覆盖equals方法来比较两个对象的内容，为了提高比较效率，java底层会先判断hashCode是否相等，如果hashCode相等，在来判断equals是否相等，如果hashCode不相等，则不会判断equals而直接返回false,只有hashCode相等，而且equals也相等，才会认为两个对象完全相等。对象相等，则hashCode也一定相等，为什么说hashCode相等，两个对象不一定相等呢？我们可以理解为hashCode是每个对象上的编码，比如假设A的hashCode是10，假设B的hashCode是11,C的hashCode是12，D的hashCode是13。
现在生成某个对象ABDhashCode为10+11+13=34,对象BBC的hashCode是11+11+12=34两个对象的hashCode相等，但是内容却是不相等的。

对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的：

•对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。

•**反射性：**x.equals(x)必须返回是“true”。

•类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。

•一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。

•任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

hashCode()的返回值和equals()的关系如下：

•如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。

•如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。