java中的Object对象理解

        Java把现实中的任何事物都当做一个对象(Object), Java是面向对象的，就是Object Orentied 简称OO 。此处的Object在Java中被定义为一个顶级父类，它是任何类父类，我们可以显示的继承它，也可以隐式继承，如以下实例：

 

public class Dog extends Object{

 

}

与

public class Dog{

 

}

 

完全等价。那么Object有什么样的作用？为什么每个类要去继承Object呢？首先来看一下Object中包含的方法。

 

1.       equals(Object obj)

2.       finalize()

3.       getClass

4.       hashCode()

5.       notify

6.       notifyAll();

7.       wait()

8.       Clone()

9.       toString()

 

其中的方法会被高频率的使用，为了实现代码复用，java 设计者就把这些常用的方法集中的放到了一个类中，这个类就是Object.

//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

 

以上实例非常简单，不多说明。

 

下面看一下对象的比较：

 

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(),当我们直接打印某个对象引用的时候，该方法就会得到调用，看一个实例：

        public static void main(String[] args) {

      

       Dog dog0 = new Dog();

      

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

            

       System.out.println(("dog0.toString():")+dog0.toString());

          

打印输出：

dog0:Dog@6b97fd

dog0.toString():Dog@6b97fd

 

两者完全等价，也就是说当我们直接打印输出引用与在引用上调用toString方法两者完全等价。

目前看到的Dog@6b97fd对我们来说没有任何的意义，为了让其变得有意义，我们可以对它进行重写。比如以上实例打印dog引用时，把dog的dogName打印输出，修改以上实例如下：

 

public class Dog{

 

    private String dogName;

 

    public String getDogName() {

       return dogName;

    }

 

    public void setDogName(String dogName) {

       this.dogName = dogName;

    }

 

 

    public String toString() {

      

       return "dog's name is:"+dogName;

    }

   

}

 

入口函数：

 

public class EqualsDemo {

 

    public static void main(String[] args) {

      

       Dog dog0 = new Dog();

      

       dog0.setDogName("xiaobai");

      

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

            

              

    }

 

 

}

 

打印输出：dog0:dog's name is:xiaobai

 

 

在此有个特殊情况，如果直接定义两个内容相同的String常量，两者会指向同样一个对象：

 

public static void main(String[] args) {

      

       String str0 = "Hello";

      

       String str1 = "Hello";

      

       System.out.println("str0==str1"+(str0==str1));

   

    }

 

打印输出：str0==str1:true

 

但是如果通过new的方式产生了String常量，则不会指向同样的对象，如一下实例：

 

    public static void main(String[] args) {

      

       String str0 = "Hello";

      

       String str1 = new String("Hello");

      

       System.out.println("str0==str1:"+(str0==str1));

   

    }

 

运行程序，打印输出：str0==str1:false

 

 

Equals 方法时常和hashCode 结合使用，主要是比较对象内容，但是在默认情况下，比较的是内存首地址。看个实例：

创建两个类：

 

public class Dog{

 

}

 

另外一个类：

 

 

 

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

 

可以通过覆盖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与hashCode结合使用的例子，该实例中想通过判断dog 的名字，如果名字相等就认为两个对象相等，如果名字不相等就认为两个对象不相等。

 

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;

        }

    }

   

}

 

其中的hashCode 方法根据对象属性加上基本的算法得到对象的hashCode并返回，得到hashCode的方法并不固定，可以对其修改。主要关注equals方法，if(obj==null)是在判断传入的对象是否为null,如果为null就返回false,认为两个对象不相等，其中if (dogName.equals(other.dogName))判断dogName字符串内容是否相等，如果相等，则返回true,否则返回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