Object类

Object类

• 类 Object是类层次结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。

equals方法

== 和 equals 的对比

• 是个比较运算符：

1. == ：既可以判断基本类型，又可以判断引用类型

2. == : 如果判断基本类型，判断的是值是否相同

3. == : 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

• equals方法

1. equals只能判断引用类型，默认判断的是地址是否相等（Object类中的equals方法），子类（Integer、String等等）中往往重写该方法，用于判断内容是否相等。

重写equals方法

package com.hspedu.object_;

public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person("jack", 10, '男');
        Person person2 = new Person("jack", 10, '男');

        System.out.println(person1.equals(person2));//false，比较的两个对象是否是同一个对象，两个new出来的肯定不是同一个对象
    }
}

class Person{ //extends Object
    private String name;
    private int age;
    private char gender;

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

重写Person的equals方法：

	@Override
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象，则直接返回true
        if(this == obj){
            return true;
        }
        //类型判断
        if(obj instanceof Person ){//如果是Person，我们才比较
            //进行 向下转型,因为我需要得到obj的各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;//this.name.equals(p.name)调用的是				String类的equals方法哦！
        }

        return false;
    }

	Person person1 = new Person("jack", 10, '男');
    Person person2 = new Person("jack", 10, '男');
	System.out.println(person1.equals(person2));//true

练习

package com.hspedu.object_;

public class EqualsExercise02 {
    public static void main(String[] args) {
        int it = 65;
        float fl = 65.0f;
        System.out.println("65和65.0f是否相等？"+(it==fl));//true

        char ch1='A';
        char ch2=12;
        System.out.println("65和'A'是否相等？"+(it==ch1));//true
        System.out.println("12和ch2是否相等？"+(12==ch2));//true 本质都是比较值

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println("str1和str2是否相等？"+(str1==str2));//false

        System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
    }
}

hashCode方法

• 提高具有Hash结构的容器的效率
• 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
• 两个引用，如果指向的是不同的对象，则哈希值是不一样的（这句话不严谨，碰撞概率极小）
• 哈希值主要是根据地址来计算的，不能完全将哈希值等价于地址（哈希值是通过该对象的内部地址转换成一个整数来实现的，但是Java语言跑在虚拟机上拿不到内部地址，但是C/C++可以）
• 案例测试：

package com.hspedu.object_;

public class HashCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hascode:"+aa.hashCode());//aa.hascode:460141958
        System.out.println("aa2.hascode:"+aa2.hashCode());//aa2.hascode:1163157884
        System.out.println("aa3.hascode:"+aa3.hashCode());//aa3.hascode:460141958
    }
}
class AA{}

• 在集合中，会重写HashCode方法

toString方法

• 基本介绍：Object中的toString方法

package com.hspedu.object_;

public class ToString_ {
    public static void main(String[] args) {
/*
        Object的toString()源码
        (1)getClass().getName()  类的全类名（包名+类名）
        (2)Integer.toHexString(hashCode())  将对象的hashCode值转成16进制的字符串
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
 */
        Monster monster = new Monster("哥斯拉", "巡山", 100);
        System.out.println(monster.toString());
        System.out.println("hashcode十进制转为十六进制后:"+Integer.toHexString(monster.hashCode()));
    }
}

class Monster{
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }

}

• 一般在子类中重写toString方法 (idea中：alt+insert 选择 toString)

	@Override
    public String toString() {//重写后，一般是把对象的属性值输出
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }

• 当直接输出一个对象时，toString方法会被默认调用 (重写后，调用重写的toString方法)

	System.out.println(monster);

finalize方法

• 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法。做一些释放资源的操作。
• 什么时候被回收：当某个对象没有任何引用时，则 JVM 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会调用finalize方法。（下面这个示例中，finalize的输出不一定会打印，垃圾回收机制并不不是时时刻刻检测的，有其内置的一套回收机制算法）

package com.hspedu.object_;

public class Finalize_ {
    public static void main(String[] args) {
        Car bmw = new Car("宝马");
        bmw = null;// 这时 car对象就是一个垃圾
        // 垃圾回收器就会回收（销毁）这个对象，在销毁对象前，会调用该对象的finalize方法
        //可以在finalize中，写自己的业务逻辑代码（比如释放资源：数据库连接或者打开文件等等）
        //如果程序员不重写finalize，那么就会调用Object类的finalzie，即默认处理
    }
}
class Car{
    private String name;

    public Car(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁汽车"+name);
    }
}

• 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制。

	System.gc();//这个也不是固定会触发上面的finalize方法

（finalize方法基本不用）