Java 常用类 02. Java Object 类

1. 基本作用

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写 extends 显示继承某个类，默认直接继承 Object 类，否则为间接继承。
• Object 类所定义的方法，是所有对象都具备的方法。
• Object 类型可以存储任何对象。
  • 作为参数，可以接受任何对象。
  • 作为返回值，可以返回任何对象。

2. 常用方法

方法名	描述
public final Class getClass()	返回此 Object 的运行时类。
public int hasCode()	返回该对象的哈希码值。
public String toString()	返回该对象的字符串表示。
public boolean equals(Object obj)	指示其他某个对象是否与此对象“相等”。
protected void finalize() throws Throwable （JDK 8 以后弃用）	当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

getClass() 方法：public final Class getClass(){}

1. 返回引用中存储的实际对象类型。
2. 应用：通常应用于判断两个引用中实际存储对象类型是否一只致。

// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型

hasCode() 方法：public int hasCode(){}

1. 返回该对象的哈希码值。
2. 哈希值根据 对象的地址 或 字符串 或 数字 使用 hash 算法计算出来的 int 类型 的数值。
3. 一般情况下，相同对象返回相同哈希码。

s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时 s3 的 hashCode 与 s1 相同

toString() 方法：public String toString(){}

1. 返回该对象的字符串表示形式（表现形式）。
2. 可以根据程序需求重写该方法。如：展示对象各个属性值
3. 对象输出时，会调用 Object 类中的 toString() 方法打印内容

// 未重写方法
System.out.println(s1.toString());  // 直接打印包名+类名+哈希值
// 重写 toString 方法 快捷键：Alt + Insert
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

equals() 方法：public boolean equals(Object obj){}

1. 默认实现为（ this == obj ）,比较两个 对象地址 是否相同。
2. 可进行重写，比较两个 对象的内容 是否相同。
3. 在 String 类中已经实现好了此方法，所以用户可直接进行两个字符串对象的比较。

System.out.println(s1.equals(s2)); // false 判断两个对象是否相等
Student s4 = new Student("A",16);
Student s5 = new Student("A",16);
System.out.println(s4.equals(s5));  // 重写方法前 false， 堆中地址不同
// String 比较
name.equals(student.name);

• 创建类

package com.base.demo03;

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;
    }

    // 重写 toString 方法 快捷键：Alt + Insert
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    // 重写 equals 方法，比较对象属性
    /*@Override
    public boolean equals(Object obj) {
        // 1. 比较两个引用是否指向同一对象
        if (this == obj) return true;
        // 2. 判断 obj 是否为空
        if (obj == null) return false;
        // 3. 判断两个引用指向的实际对象类型是否一致
        // if (this.getClass() == obj.getClass()) return true;
        // instanceof 判断对象是否是某种类型
        if (obj instanceof Student) {
            // 4.强制类型转换
            Student s = (Student) obj;
            // 5.比较属性
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        return false;
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null) return false;
        if (!(o instanceof Student)) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name.equals(student.name);
    }
}

• 测试类：

package com.base;

import com.base.demo03.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student("Liu",20);
        Student s2 = new Student();
        Student s4 = new Student("A",16);
        Student s5 = new Student("A",16);
        // 1. getClass 方法
        // 判断 s1 s2 是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s1.getClass();
        System.out.println("========== 1. getClass ==================");
        System.out.println(class1);
        if(class1==class2){
            System.out.println("s1、s2 属于同一类型");
        }else {
            System.out.println("s1、s2 不属于同一类型");
        }
        System.out.println("============ 2. hashCode ================");
        // 2. hashCode 方法
        System.out.println("s1:"+s1.hashCode());
        System.out.println("s2:"+s2.hashCode());
        Student s3 = s1;    // 此时 s3 的 hashCode 与 s1 相同
        System.out.println("s3:"+s3.hashCode());
        System.out.println("s4:"+s4.hashCode());
        System.out.println("s5:"+s5.hashCode());
        System.out.println("============ 3. toString ================");
        // 3. toString
        System.out.println("s1:"+s1.toString());  // 直接打印包名+类名+哈希值
        System.out.println("s2:"+s2.toString());
        System.out.println("s3:"+s3.toString());
        System.out.println("s4:"+s4.toString());
        System.out.println("s5:"+s5.toString());
        System.out.println("============ 4. equals ================");
        // 4. equals
        // 判断两个对象是否相等
        System.out.println("s1 VS s2:"+s1.equals(s2));  // false
        System.out.println("s1 VS s3:"+s1.equals(s3));  // true
        // 重写方法前,堆中地址不同
        System.out.println("s4 VS s5:"+s4.equals(s5));  // false
    }
}

• 重写 toString()、equals() 方法前运行结果：

• 重写 toString()、equals() 方法后运行结果：

finalize() 方法（JDK 8 以后弃用）：protected void finalize() throws Throwable{}

• 当对象被判定为垃圾对象时，由 JVM 自动调用此方法，用以标记垃圾对象，进入回收对列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由 GC 销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM 的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用 System.gc(); 通知 JVM 执行垃圾回收。
• 实例：类中重写 finalize() 方法

@Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"垃圾被回收");
    }

• 测试类

package com.base;

import com.base.demo03.Student;

public class Application {
    public static void main(String[] args) {
        /*Student s1 = new Student("A01", 20);  // 不是垃圾，不被回收
        Student s2 = new Student("A02", 21);
        Student s3 = new Student("A03", 22);
        Student s4 = new Student("A04", 23);
        Student s5 = new Student("A05", 24);*/
        new Student("A01", 20); // 是垃圾，被回收
        new Student("A02", 21);
        new Student("A03", 22);
        new Student("A04", 23);
        new Student("A05", 24);
        // 回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

• 运行结果：

总结

• 实际开发中的作用，由于 Object 类可以接收任意的引用数据类型，所以在很多的类库设计上都采用 Object 作为方法的参数，这样操作起来更方便。
• Object 类中还有一些方法如 wait()、notify() 等通常用在线程上。
• getClass()用来获取对象类型
• hashCode()用来获取对象的哈希值
• equals()用来比较两个对象是否是同一个
• toString()用来打印输出对象的属性信息，默认输出信息不满足需要，可以将该方法进行重写
• finalize()用来回收垃圾对象