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(){}
- 返回引用中存储的实际对象类型。
- 应用：通常应用于判断两个引用中实际存储对象类型是否一只致。
// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型
hasCode()方法：public int hasCode(){}
- 返回该对象的哈希码值。
- 哈希值根据 对象的地址 或 字符串 或 数字 使用 hash 算法计算出来的 int 类型 的数值。
- 一般情况下，相同对象返回相同哈希码。
s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时 s3 的 hashCode 与 s1 相同
toString()方法：public String toString(){}
- 返回该对象的字符串表示形式（表现形式）。
- 可以根据程序需求重写该方法。如：展示对象各个属性值
- 对象输出时，会调用
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){}
- 默认实现为（ this == obj ）,比较两个 对象地址 是否相同。
- 可进行重写，比较两个 对象的内容 是否相同。
- 在 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()用来回收垃圾对象
网友评论