Java Object类详解与常用方法分析-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_62520622/article/details/121538088

1、API概述以及Object类的概述

API(Application Programming Interface)
应用程序编程接口

Java API
就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类

2、Object类的hashCode()方法

public int hashCode()

a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
       b:不同对象的，hashCode()一般来说不会相同。
       但是，同一个对象的hashCode()值肯定相同。
       c:不是对象的实际地址值，可以理解为逻辑地址值

package org.westos.demo1;
//import java.lang.Object;  //java.lang 包下的类，导入语句可以省略不写
public class MyTest {
    public static void main(String[] args) {
        //Object 所有类的顶层父类，所有类都是直接或间接继承自他
        Object obj = new Object();
        System.out.println(obj);
        //返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
        int i = obj.hashCode();
        System.out.println(i);
        Object obj1 = new Object();
        int i1 = obj1.hashCode();
        System.out.println(i1);
        //不同对象哈希码值不同
    }
}

3、Object类的getClass()方法

   public final Class getClass()
       a:返回此 Object 的运行时类。
       b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
       public String getName()

public class MyTest2 {
    public static void main(String[] args) {
        //Object.java--编译----Object.class(字节码文件)----->Object.class加载，
        // 虚拟机就会创建该字节码文件的对象。用Classs类型来表示字节码类型
        Object obj = new Object();
        //获取该类的字节码文件对象。
        Class<?> aClass = obj.getClass();

        Object obj2 = new Object();
        Class<?> aClass2 = obj2.getClass();
        System.out.println(obj==obj2); //false

        Object object3 = new Object();
        Class<?> aClass3 = object3.getClass();

        System.out.println(aClass==aClass2); //true
        System.out.println(aClass2 == aClass3);//true

    }
}

4、Object类的toString()方法

public String toString()
a:返回该对象的字符串表示。
       源代码:
          public String toString() {
                    return getClass().getName() + "@" + Integer.toHexString(hashCode());
               }
   b:它的值等于：
       getClass().getName() + '@' + Integer.toHexString(hashCode())
   c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
   怎么重写, 一般是将该类的所有的成员变量组成返回即可

直接输出对应的名称,就是调用对象的toString()方法

当你打印对象名的时候，其实后面调用了toString()方法，只是我们经常省略不写：

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        //toString() 方法或对象的地址值，以字符串形式返回。
        String s = obj.toString();
        System.out.println(s);
        //当你打印对象名的时候，其实后面调用了toString()方法，只是我们经常省略不写。
        System.out.println(obj);

    }
}

定义Student类，并重写toString()方法：

public class Student {
    private String name;
    private int 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;
    }

    public void show() {
        System.out.println(name + "====" + age);
    }

    //一般我们自定义的类，重写toString()方法时，是喜欢输出成员变量的值
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

新建学生对象，输出查看toString()方法重写的结果：

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(23);

        student.show();

         System.out.println(student.toString());
    }
}

输出结果：

如果你以后打印一个对象名，没有输出地址值，说明该类重写了父类Object类的toString()

public class MyTest2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //如果你以后打印一个对象名，没有输出地址值，说明该类重写了父类Object类的toString();
        System.out.println(scanner);
    }
}

5、Object类的equals()方法

a:指示其他某个对象是否与此对象“相等”。
       源代码:
               public boolean equals(Object obj) {
                   return (this == obj);
               }
   b:默认情况下比较的是对象的引用是否相同。
   c:由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等

建Student类，并重写equals方法：

public class Student {
    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;
    }

    public void show() {
        System.out.println(name + "====" + age);
    }
    //重写equals方法： 比较两个对象的成员变量的值是否相同。
    // boolean b = s1.equals(s2);
    /*
     * 代码的健壮性。考虑周全一些。在从性能上考虑
     * */
    @Override
    public boolean equals(Object obj) {  // Object obj=s2  Student
        //对传入的参数做非空判断
        if(obj==null){
            return false;
        }
        //从性能上来考虑
        if(this==obj){
            return true;
        }
        //多态形式访问成员变量，编译看左边，运行看左边。
        //向下转型，得判断 instanceof
        // instanceof 判断一个引用或对象，是不是该类型的引用或对象
        if (!(obj instanceof Student)) { //判断obj这个引用 是不是Student类型的引用
            return false;
        }
        //向下转型
        Student s2= (Student) obj;
        // 23==24 && "李四"=="李四"
        // String 引用类型 ==号比较两个对象比较的是地址值 我们现在的意思是想要比较这两个字符串字面上的内容是否相同
        //我们要比较两个字符串，字面上的内容是否相同，要调用字符串中的 equals() 方法来比较
        return this.age == s2.age && this.name.equals(s2.name);
    }
}

equals 默认情况下比较的是对象的引用是否相同，重写后比较成员变量值：

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2= new Object();
        //== 号可以判断两个对象的地址值，是否相同
        System.out.println(obj==obj2);

        /*
        *   public boolean equals(Object obj) {
                 return (this == obj);
            }
        * */
        boolean b = obj.equals(obj2);
        System.out.println(b);


        Student student = new Student("q",23);
        Student student1 = new Student("q",23);
        System.out.println(student==student1);

        boolean equals = student.equals(student1);
        System.out.println(equals);

    }
}

6、Object类的equals()方法代码优化

   Object类的equals()方法代码优化
       a: 提高效率
       b: 提高健壮性(instanceof)

Student类中重写为例：

@Override
    public boolean equals(Object o) {
        //如果自己跟自己比较，直接true
        if (this == o) {
            return true;
        }
        // 判断一个引用或对象，是不是该类型的引用或对象
        //s1.getClass()==s2.getClass();
        // instanceof 判断一个引用或对象，是不是该类型的引用或对象
        if (o==null||this.getClass() != o.getClass()) {
            return false;
        }
        //向下转型
        Student student = (Student) o;
       /*
       *      public static boolean equals(Object a, Object b) {
                        return (a == b) || (a != null && a.equals(b));
                }
       *
       * */
        //return this.age == s2.age && this.name.equals(s2.name);
        return this.age == student.age && Objects.equals(name, student.name);
    }

7、Object类的clone() 方法

clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public 对象的浅克隆:浅克隆和深克隆使用clone()方法采用的是浅克隆的方式

对象浅克隆要注意的细节：

如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。

Cloneable接口只不过是一个标识接口而已，没有任何方法。

对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。

对象的浅克隆也不会调用到构造方法的。

如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口
Cloneable接口只不过是一个标识接口而已，没有任何方法

package org.westos.demo3;

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dog dog = new Dog(5,"小白");
        Dog dog2= (Dog)dog.clone();
        System.out.println(dog);
        System.out.println(dog2);
    }
}
// Cloneable 接口里面没有任何抽象方法，这个接口，就是个标记接口，给类打个标记，目的告诉JVM要执行克隆操作
class Dog implements Cloneable{
    private String name;
    private  int age;


    public Dog() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//继续调用父类Object的克隆
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
对象的浅克隆也不会调用到构造方法的。

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {

        /*
        *  3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，
        * 这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
	        4. 对象的浅克隆也不会调用到构造方法的。
        *
        * */
        DogFood dogFood = new DogFood("金锣");
        Dog dog = new Dog("小白", 2, dogFood);
        dog.dogFood.foodName="王中王";

        //克隆
        Dog dog2 = (Dog) dog.clone();
        dog2.dogFood.foodName="玉米肠";

        System.out.println(dog.dogFood.foodName); // 玉米肠

        System.out.println(dog2.dogFood.foodName); // 玉米肠

    }
}

class Dog implements Cloneable {
    String name;
    int age;
    //成员变量，DogFood类型
    DogFood  dogFood;
    public Dog() {

    }
    public Dog(String name, int age, DogFood dogFood) {
        System.out.println("构造方法调用了");
        this.name = name;
        this.age = age;
        this.dogFood = dogFood;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone(); //继续调用父类Object的克隆
    }
}

class DogFood{
    String foodName="双汇";
    public DogFood() {
    }
    public DogFood(String foodName) {
        this.foodName = foodName;
    }
}

内存图：