04.所有类的顶级父类Object

一.概述：

二.Object的构造方法：

只有一个空参构造方法，因为子类里的共性才会抽取到父类，而子类有各种各样，不可能有哪一个属性是所有子类共有的，因此顶级父类Object类就不会有成员变量，也就没有带参构造方法

->这也就解释了针对任意一个类的所有构造方法，在第一行都有一个隐藏的super()即默认访问父类的无参构造，而不是访问父类的有参构造，是因为顶级父类Object类中只有无参构造方法

三.Object类的成员方法：

1.toString方法:返回对象的字符串表示形式

getClass().getName()：可得出包名加类名；

@为固定格式；

Integer.toHexString(hashCode())：可以获取到对象的地址值，但获取到地址值后是经过了一系列的复杂运算，再变成十六进制，最终得出；

toString方法的结论：默认情况下，Object类中的toString方法返回的是地址值， 因此默认情况下打印一个自定义对象其实就是打印它的地址值 但通常地址值用处不大，为了不打印地址值， 可通过重写顶级父类即Object类中的toString方法来重新输入自己所需要的内容；

2.println方法：

关键：valueOf方法(返回字符串)，做了如下判断，先判断对象是否为空，如果为空，返回字符串null，如果不为空，用对象调用toString方法

writeln方法：其中有一个implWriteln方法，textOut.write(s)是打印，textOut.newLine()是换行

System.out.println这个打印语句的核心逻辑:当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串，然后再打印在控制台上，打印完毕最后做换行处理。

3.equals方法：

自定义类中如果没有重写equals方法，那么默认使用顶级父类Object里的equals方法进行比较，顶级父类Object里的equals方法默认比较两个对象的地址值是否相同，大多数地址值用处不大，实际中通常会比较对象的属性值，为了比较属性值或者其他内容，就需要重写顶级父类Object里的equals方法。

四.代码演示：

1.toString方法:

未重写顶级父类即Object类中的toString方法时：

package a10ObjectDemo;
​
public class Student {
    //自定义的类，没有手动继承其他的类，因此默认继承Object类
    private String name;
    private int age;
​
    public Student(){
    }
​
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}
​

package a10ObjectDemo;
​
public class ObjectDemo1 {
    public static void main(String[] args) {
        //1.toString方法:返回对象的字符串表示形式
        Object obj = new Object();
        String str1 = obj.toString();
        System.out.println(str1);
        /*运行结果为java.lang.Object@b4c966a
          @之前是包名加类名
          @本身是固定格式
          @后面的是该对象的地址值 */
​
        Student stu=new Student();
        String str2 = stu.toString();
        System.out.println(str2);
        //运行结果为a10ObjectDemo.Student@4e50df2e
​
        //细节：如果不调用toString方法，而是直接打印stu对象
        System.out.println(stu);
        //运行结果为a10ObjectDemo.Student@4e50df2e，和调用toString方法的结果一样
        /*System是一个类,out是类System的一个静态变量
          System.out简单理解为获取到打印对象
          println是一个方法，参数表示要打印的内容*/
        /*System.out.println这个打印语句的核心逻辑:当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串，
        然后再打印在控制台上，打印完毕最后做换行处理*/
​
        /*默认情况下，Object类中的toString方法返回的是地址值，
        因此默认情况下打印一个自定义对象其实就是打印它的地址值
        但通常地址值用处不大，为了不打印地址值，
        可通过重写顶级父类即Object类中的toString方法来重新输入自己所需要的内容*/
    }
}

​

重写顶级父类即Object类中的toString方法时：

package a10ObjectDemo;
​
public class Student {
    //自定义的类，没有手动继承其他的类，因此默认继承Object类
    private String name;
    private int age;
​
    public Student(){
    }
​
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return name+", "+age;
    }
}
​

package a10ObjectDemo;
​
public class ObjectDemo1 {
    public static void main(String[] args) {
        //1.toString方法:返回对象的字符串表示形式
        Object obj = new Object();
        String str1 = obj.toString();
        System.out.println(str1);
        /*运行结果为java.lang.Object@b4c966a
          @之前是包名加类名
          @本身是固定格式
          @后面的是该对象的地址值 */
​
        Student stu=new Student("张三",23);
        String str2 = stu.toString();
        System.out.println(str2);
        //运行结果为张三, 23
​
        //细节：如果不调用toString方法，而是直接打印stu对象
        System.out.println(stu);
        //运行结果为张三, 23，和调用toString方法的结果一样
        /*System是一个类,out是类System的一个静态变量
          System.out简单理解为获取到打印对象
          println是一个方法，参数表示要打印的内容*/
        /*System.out.println这个打印语句的核心逻辑:当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串，
        然后再打印在控制台上，打印完毕最后做换行处理*/
​
        /*默认情况下，Object类中的toString方法返回的是地址值，
        因此默认情况下打印一个自定义对象其实就是打印它的地址值
        但通常地址值用处不大，为了不打印地址值，
        可通过重写顶级父类即Object类中的toString方法来重新输入自己所需要的内容*/
    }
}
​

2.equals方法：

未重写顶级父类即Object类中的equals方法时：

package a10ObjectDemo;
​
public class Student {
    //自定义的类，没有手动继承其他的类，因此默认继承Object类
    private String name;
    private int age;
​
    public Student(){
    }
​
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return name+", "+age;
    }
​
}

​

package a10ObjectDemo;
​
public class ObjectDemo2 {
    public static void main(String[] args) {
        Student s1=new Student();
        Student s2=new Student();
​
        boolean result1 = s1.equals(s2);
        System.out.println(result1);
        /*运行结果为false。equals方法是s1调用的，s1是Student型，但此时Student类里
        没有equals方法，所以会找父类即会找到顶级父类Object里的equals方法，顶级父类Object里的equals方法
        默认比较两个对象的地址值是否相同。s1和s2都是new出来的，地址值会不一样，自然equals方法返回false。
        大多数地址值用处不大，实际中通常会比较对象的属性值，为了比较属性值或者其他内容，就需要重写顶级父类Object里的equals方法*/
​
    }
}
​

重写顶级父类即Object类中的equals方法时：

package a10ObjectDemo;
​
import java.util.Objects;
​
public class Student {
    //自定义的类，没有手动继承其他的类，因此默认继承Object类
    private String name;
    private int age;
​
    public Student(){
    }
​
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return name+", "+age;
    }
​
    //重写之后的equals方法比较的就是对象内部的属性值了
    @Override
    public boolean equals(Object o) {
        //1.首先会比较调用者this和参数里的对象是否是同一个对象
        if (this == o) return true; //该if语句中比较的是地址值,地址值一样就说明是同一个对象
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    
}
​

package a10ObjectDemo;
​
public class ObjectDemo2 {
    public static void main(String[] args) {
        Student s1=new Student();
        Student s2=new Student();
​
        boolean result1 = s1.equals(s2);
        System.out.println(result1);
        /*运行结果为true，因为属性值都是空参，是一样的，所以结果为true*/
​
    }
}
​

五.练习：

package a10ObjectDemo;

public class ObjectDemo3 {
    public static void main(String[] args) {
        String s="abc";
        StringBuilder sb=new StringBuilder("abc");

        System.out.println(s.equals(sb));
        /*运行结果为false，equals方法是被s调用的，s是String型，因此equals方法是需要看String类里的，
          字符串String类里的equals方法，先判断参数是否为字符串，如果是字符串，再比较内部属性,
          内部属性一致返回true，不一样返回false，如果参数不是字符串，直接返回false*/
        //sb不是字符串，而是StringBuilder对象

        System.out.println(sb.equals(s));
        /*运行结果为false，equals方法是被sb调用的，sb是StringBuilder型，因此equals方法是需要看StringBuilder类里的，
          StringBuilder类里没有重写equals方法，StringBuilder继承于AbstractStringBuilder，
          AbstractStringBuilder类里也没有重写equals方法，因此StringBuilder类里默认使用它的顶级父类Object类里的equals方法，
          顶级父类Object类里的equals方法默认比较地址值，由于s和sb地址值不一样，所以返回false*/
    }
}

String类里的equals方法：首先把调用者和参数比较，一样的话返回true，不一样的话走第二个return语句，首先判断是否是字符串String型，不是的话返回false，是的话继续比较内部属性，内部属性一致返回true，不一样返回false：

StringBuilder类里没有重写equals方法，StringBuilder继承于AbstractStringBuilder，AbstractStringBuilder类里也没有重写equals方法，因此StringBuilder类里默认使用它的顶级父类Object类里的equals方法，顶级父类Object类里的equals方法默认比较地址值。