知识点-- Object类概述

目标:

• 了解Object的概述和常用方法

路径:

• Object类的概述
• Object类中常用的2个方法

讲解:

Object类的概述

• java.lang.Object类是Java语言中的根类，即所有类的父类。

  如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class Fu /*extends Object*/ {
  	// ...
}
public class Zi extends Fu{
    
}

• 根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

• public String toString()：返回该对象的字符串表示。

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

小结

• Object类是java中的根类，即所有类的父类
• java中所有的类都是直接或者间接继承Object类,也就意味着,java中所有的类都拥有Object类中的那11个方法

知识点-- toString方法

目标:

• 能够正确使用toString方法

路径:

• toString方法的概述
• 重写toString方法

讲解:

toString方法的概述

• public String toString()：返回该对象的字符串表示，其实该字符串内容就是：对象的类型名+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

重写toString方法

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person {
    public String name;
    public int age;

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

    public Person() {
    }

   // 快捷键:alt+insert===>toString
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在IntelliJ IDEA中，可以点击Code菜单中的Generate...，也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。

小贴士： 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

小结

• toString方法默认返回的字符串内容格式: 对象的类型+@+十六进制数的地址值
• 打印对象的时候,其实就是打印该对象调用toString方法返回的字符串内容
• 如果打印对象的时候不希望打印的是地址值的形式,那么就可以去重写toString方法,指定返回的字符串内容格式 ---->一般开发中,重写toString方法—alt+insert—>toString() 回车

知识点-- equals方法

目标:

• 掌握equals方法的使用

路径:

• equals方法的概述
• equals方法的使用

讲解:

equals方法的概述

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

equals方法的使用

默认地址比较

Object类的equals()方法默是==比较,也就是比较2个对象的地址值,对于我们来说没有用

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

public class Person {
    public String name;
    public int age;

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

   // 快捷键:alt+insert===>toString
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*@Override
    public boolean equals(Object obj) {
        // 自定义比较规则
        Person p = (Person)obj;
        return this.age == p.age && this.name.equals(p.name);
    }*/

    // 快捷键:alt+insert-->选择equals and hashCode

    @Override
    public boolean equals(Object o) {
        // 如果2个对象的地址值相同,就直接返回true,结束方法
        if (this == o) return true;
        // 如果参数为null或者2个对象所属的类不相同,就直接返回false,结束方法
        if (o == null || getClass() != o.getClass()) return false;
        // 来到这里,说明要比较的2个对象,地址值一定不同,并且都是Person类型的对象
        Person person = (Person) o;
        // 比较所有属性是否完全相同
        return age == person.age &&
                Objects.equals(name, person.name);
    }

}

public class Test {
    public static void main(String[] args) {
        /*
            Object类的equals方法:
                public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
                默认地址比较
                    Object类的equals()方法默是==比较,也就是比较2个对象的地址值,对于我们来说没有用

                对象内容比较
                    如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。
         */
        // 创建Person对象
        Person p1 = new Person("张三",18);
        Person p2 = new Person("李四",19);
        Person p3 = new Person("张三",18);
        // ==比较
        System.out.println(p1 == p2);// false
        System.out.println(p1 == p3);// false
        // 没有重写equals方法,使用的就是Object类的equals方法
        // equals方法比较
        //System.out.println(p1.equals(p2));// false  相当于p1==p2
        //System.out.println(p1.equals(p3));// false  相当于p1==p3

        // 重写equals方法,使用的就是Person类重写的equals方法
        System.out.println(p1.equals(p2));// false
        System.out.println(p1.equals(p3));// true

    }
}

这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。

tips：Object类当中的hashCode等其他方法，今后学习。

小结

• 概述: equals方法可以判断两个对象是否相同

1.Object类的equals方法默认比较的是2个对象的地址值是否相同  ==一样的效果
2.如果在开发中,希望调用equals方法比较的不是2个对象的地址值,那么就需要重写equals方法,指定比较规则
  一般开发中,重写equals方法,使用idea的快捷键alt+insert--->equals and hashCode 回车

知识点-- Objects类

目标:

• Objects类

路径:

• Objects类的概述
• Objects类中的equals方法的使用

讲解:

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

• public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

知识点-- native方法

目标

• 理解什么是native方法,以及native方法的作用

路径

• native本地方法的概述

讲解

在Object类的源码中定义了 native 修饰的方法， native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,所以大家不需要关心该方法如何实现的

• 当我们需要访问C或C++的代码时，或者访问操作系统的底层类库时，可以使用本地方法实现。

  也就意味着Java可以和其它的编程语言进行交互。

• 本地方法的作用： 就是当Java调用非Java代码的接口。方法的实现由非Java语言实现，比如C或C++。

Object类源码(部分)：

package java.lang;
/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {
	//本地方法
    private static native void registerNatives();
    //静态代码块
    static {
        registerNatives();
    }
    ......
    ......
}

根父类 java.lang.Object

根父类java.lang.Object

Object类是所有Java类的根父类

根父类

如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类
public class Person {
	...
}
	等价于：
public class Person extends Object {
...
}

根父类java.lang.Object

根据继承的特点

（1）父类中所有的属性和方法都会继承到子类中，或者说所有对象都具有Object类的方法，包括数组对象
所有对象都具有Object类的方法
（2）所有的子类都会调用它的构造器，super()
所有子类都会调用Obejct类的构造器

根据多态的特性

（1）Object类型的引用变量可以接收任何类型的对象
Object obj=new Person();
Object obj = “hello”;

…
Object类是所有Java类的根父类

（2）Object类型的形参可以接收任何类型的实参
例如：
void method(Object obj){}
调用：
method(new Person());
method(“hello”);
method(null);

（3）数组的多态性：当数组的元素类型是Object时，表示这个数组可以存放任意类型的对象

Object[] object = new Object[5];

根父类java.lang.Object
1、java.lang.Object类是类层次结构的根父类。包括数组对象。

（1）Object类中声明的所有的方法都会被继承到子类中，那么即所有的对象，都拥有Object类中的方法

（2）每一个对象的创建，最终都会调用到Object实例初始化方法()

（3）Object类型变量、形参、数组，可以存储任意类型的对象

2、Object类的常用方法

toString()

（1）public String toString()：

①默认情况下，返回的是“对象的运行时类型 @ 对象的hashCode值的十六进制形式"

②通常是建议重写，如果在eclipse中，可以用Alt +Shift + S–>Generate toString()，在IDEA ，Alt + Insert 重写toString()

③如果我们直接System.out.println(对象)，默认会自动调用这个对象的toString()

（2）public final Class<?> getClass()：获取对象的运行时类型

（3）protected void finalize()：当对象被GC确定为要被回收的垃圾，在回收之前由GC帮你调用这个方法。而且这个方法只会被调用一次。子类可以选择重写。

（4）public int hashCode()：返回每个对象的hash值。

规定：①如果两个对象的hash值是不同的，那么这两个对象一定不相等；

​ ②如果两个对象的hash值是相同的，那么这两个对象不一定相等。

主要用于后面当对象存储到哈希表等容中时，为了提高性能用的。

（5）public boolean equals(Object obj)：用于判断当前对象this与指定对象obj是否“相等”

①默认情况下，equals方法的实现等价于与“==”，比较的是对象的地址值

②我们可以选择重写，重写有些要求：

A：如果重写equals，那么一定要一起重写hashCode()方法，因为规定：

​ a：如果两个对象调用equals返回true，那么要求这两个对象的hashCode值一定是相等的；

​ b：如果两个对象的hashCode值不同的，那么要求这个两个对象调用equals方法一定是false；

​ c：如果两个对象的hashCode值相同的，那么这个两个对象调用equals可能是true，也可能是false

B：如果重写equals，那么一定要遵循如下几个原则：

​ a：自反性：x.equals(x)返回true

​ b：传递性：x.equals(y)为true, y.equals(z)为true，然后x.equals(z)也应该为true

​ c：一致性：只要参与equals比较的属性值没有修改，那么无论何时调用结果应该一致

​ d：对称性：x.equals(y)与y.equals(x)结果应该一样

​ e：非空对象与null的equals一定是false

参考资料
搞定Java核心技术

Object类

在Java中的所有类都是从Object这个类继承出来的，Object类是所有类的源头，是所有类的父类。
你可以想象自己写的类是这样声明的：

public class Dog extends Object {}

Object类的部分方法：

1.
equals(Object o)   //判断是否相等

Dog a = new Dog();
Cat c = new Cat();
boolean b = a.equals(c);   //false

2.
getClass()

Cat c = new Cat();
System.out.println(c.getClass());    //class cat ,告诉你此对象是从哪里被初始化的

3.
hasCode()
Cat c = new Cat();
System.out.println(c.hasCode());   //  8202111 ,列出此对象的哈希代码，你可以把它想象成一个唯一的ID

4.
toString()
Cat c = new Cat();
System.out.println(c.toString());   //列出类的名称和一个我们不关心的数字

关于Object类的几点说明：

• Object类不是抽象类
• Object类的部分方法可以被覆盖，被标记为final的方法不能被覆盖，强烈建议用自己写的类去覆盖掉hashCode(),equals(),toString()
• ArrayList方法是通用的，入参或返回类型为object，ArrayList<Dog>是用于限制它的类型，表明此ArrayList受限只能保存Dog对象，在java5.0之前无法限制它的类型。
• Object类有两个主要的目的，作为多态让方法可以应付多种类型的机制，以及提供Java在执行期对任何对象都有需要的方法的实现程序代码（让所有的类都会继承到）

使用Object类型的多态引用的代价：

• 任何从ArrayList取出的东西都会被当作Object类型的引用而不管它原来是什么，编译器无法将此对象识别为Object以外的事物。
• 编译器只管引用的类型，而不是对象的类型，编译器是根据引用类型来判断有哪些method可以调用，而不是根据Object确实的类型

public void go() {
	Dog d = new Dog();
	Dog a = getObject(d);  //这是错误的，无法过关，虽然返回了同一个Dog，但编译器认为这只能赋值给Object类型的变量
}

public Object getObject(Object o) {
	return o;  //返回了同一个引用，但类型已经转换为Object了
}

如何将Object类转换为原来的类型

ArrayList<Object> myDogs = new ArrayList<Object>();
Dog d = new Dog();
Dog a = (Dog) mydogs.get(0)

如果你真的确定它是个Dog，可以使用(Dog)将类型转换为Dog.
如果你不能确定它是Dog，可以使用instanceOf这个运算符来检查，若是类型转换错了，你会在执行期遇到ClassCastException异常并且终止。

if (o instance of Dog) {
	Dog a = (Dog) o;
}