Object类

• 超类、基类，所有类直接或间接父类，位于继承树的最顶层
• getClass()方法
  • public final Class<?> getClass(){}
  • 返回引用中存储的实际对象类型
  • 通常用于判断两个引用中实际存储对象类型是否一致

public class Student{
    private String name;
    private int age;
    
    public Student(){}
    
    public Student(String name,int age){
        super();
        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 class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa",10);
        Student s2 = new Student("bbb",20);
        
        //判断s1和s2是不是同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        
        if(class1 == class2){
            System.out.println("s1和s2是同一个类型");
        }else{
            System.out.println("s1和s2不是同一个类型");
        }
    }
}

/*运行结果：s1和s2是同一个类型*/

• hashCode()方法
  • public int hashCode(){}
  • 返回该对象的哈希码值
  • 哈希值根据对象的地址或者字符串或者数字使用hash算法计算出来的int类型的数值
  • 一般情况下相同对象返回相同哈希值码

public class Student{
    //...
    //同上
    //...
}

public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa",10);
        Student s2 = new Student("bbb",20);
        
        //hashCode方法
        System.out.println(s1.hashCode()); //366712642
        System.out.println(s2.hashCode()); //1829164700
        
        Student s3 = s1;
        System.out.println(s3.hashCode()); //366712642
    }
}

• toString()方法
  • public String toString(){}
  • 返回该对象的字符串表示（表现形式）
  • 可以根据程序需求覆盖该方法

public class Student{
    //...
    //同上
    //...
    @Override
    Public String toString(){
        return name + ":" + age;
    }
}

public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa",10);
        Student s2 = new Student("bbb",20);
        
        //toString方法
        System.out.println(s1.toString()); //aaa:10
        System.out.println(s2.toString()); //bbb:20
    }
}

• equals()方法
  • public boolean equals(Object obj){}
  • 默认实现为（this == obj），比较两个对象的地址是否相同
  • 可进行覆盖，比较两个对象的内容是否相同，覆盖步骤如下：
    1. 比较两个引用是否指向同一个对象
    2. 判断obj是否为null
    3. 判断两个引用指向的实际对象类型是否一致
    4. 强制类型转换
    5. 依次比较各个属性值是否相同

public class Student{
    //...
    //同上
    //...
    @Override
    public boolean equals(Object obj){
        //1.判断两个对象是否是同一个引用
        if(this == obj){
            return true;
        }
        //2.判断obj是否为null
        if(obj == null){
            return false
        }
        //3.判断是否是同一个类型
        if(obj instanceof Student){
            //4.强制类型转换
            Student s = (Student) obj;
            //5.比较属性
            if(this.name.equals(s.getName())&&this.age == s.getAge()){
                return true;
            }
        }
        return false;
    }
}

public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa",10);
        Student s2 = new Student("bbb",20);
        Student s3 = new Student("ccc",10);
        Student s4 = new Student("ccc",10);
        
        //equals方法
        System.out.println(s1.equals(s2)); //false
        System.out.println(s3.equals(s4)); //不重写equals方法返回false，地址不同，重写后返回true
    }
}

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

public class Student{
    //...
    //同上
    //...
    @Override
    public void finalize() throws Throwable{
        System.out.println(this.name + "对象被回收了");
}

public class Test{
    public static void main(String[] args){
        Student s1 = new Student("aaa",10);
        Student s2 = new Student("bbb",20);
        Student s3 = new Student("ccc",10);
        Student s4 = new Student("ddd",10);
        Student s5 = new Student("eee",10);
        
        //垃圾回收
        System.gc();
        System.out.println("回收垃圾"); //回收垃圾，创建的对象没被回收
    }
}
   
public class Test2{
    public static void main(String[] args){
        new Student("aaa",10);
        new Student("bbb",20);
        new Student("ccc",10);
        new Student("ddd",10);
        new Student("eee",10);
        
        //垃圾回收
        System.gc();
        System.out.println("回收垃圾"); 
        
        /*运行结果
        回收垃圾
        aaa对象被回收了
        bbb对象被回收了
        ccc对象被回收了
        ddd对象被回收了
        eee对象被回收了
        */
    }
}