java常用类-Object

1.Object类
概念：超类、基类，所有类的直接或间接的父类，位于继承树的最顶层；
特点：任何类，如果没有书写extends显式继承某个类，都默认直接继承Object类，否则为间接继承；
Object类中所定义的方法，是所有对象都具备的方法；
Object类型可以存储任何对象：
作为参数，可接收任何对象；
作为返回值，可返回任何对象；

.getClass()
public final Class<?> getClass(){}
返回引用中存储的实际对象的类型；
通常用于判断两个引用中实际存储对象类型是否一致；

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

.toString()
public String toString(){}
返回该对象的字符串表示（表现形式），默认是类的全名@哈希值；
可以根据程序需求重写该方法，如，展示对象各个属性

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

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

public class Object {
    public static void main(String[] args) {
        Student s1 = new Student("a", 1);
        Student s2 = new Student("b", 2);

        System.out.println("---1.getClass()------------------");
        //判断s1和s2是否为同一个类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if (class2==class1) {
            System.out.println("s1和s2属于同一个类型！");
        } else {
            System.out.println("s1和s2不属于同一个类型。");
        }

        System.out.println("---2.hashCode()------------------");
        //判断s1和s2的哈希值是否相等
        System.out.println(s2.hashCode()==s1.hashCode());//false
        Student s3=s1;
        System.out.println(s3.hashCode()==s1.hashCode());//true

        System.out.println("---3.toString()-----------------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());

        System.out.println("---4.equals()-------------------");
        System.out.println(s1.equals(s2));//false
        Student s4 = new Student("Tom", 10);
        Student s5 = new Student("Tom", 10);
        System.out.println(s4.equals(s5));//true

        System.out.println("---5.finalize()-----------------");
        Student stu1=new Student("a",1);
        new Student("b",1);
        new Student("c",1);
        //回收垃圾
        System.gc();//没有调用finalize()?
        System.out.println("回收垃圾:");
    }
}
//学生类
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;
    }
    //重写object的toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写object的equals()
    @Override
    public boolean equals(java.lang.Object obj) {
        //1.判断两个对象是否是同一个引用
        System.out.println(this.getClass());
        System.out.println(obj.getClass());
        if (this==obj) {
            return true;
        }
        //2.判断obj是否为null
        if (obj==null) {
            return false;
        }
        //3.判断是否为同一个类型
        //if (this.getClass()==obj.getClass()){ } 不推荐这种方式！
        if (obj instanceof Student){//不能用this.getClass() 代替 Student?
            //4.强制类型转换
            Student s=(Student) obj;
            if(this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
    //重写垃圾标记finalize()
    @Override
    protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了");
    }
}

if (obj instanceof Student){//不能用this.getClass() 代替 Student?
System.gc();//没有调用finalize()?