Object 类的几个常用方法

    在 Java 中，Object 类是所有类的根类，所有类都直接或间接继承自 Object 类。Object 类提供了几个常用的方法，这些方法可以被所有类继承和重写。所以有必要了解一下 Object 里的几个常用方法：

1.equal

(1)默认用法

默认：Object 类中的 equals() 方法默认使用 == 进行比较，即比较两个对象的引用是否指向同一个内存地址。

代码示例：

public boolean equals(Object obj) {
    return (this == obj);
}

(2)重写用法

重写目的：根据对象的实际内容（属性值）来判断两个对象是否相等

重写示例：在下面的例子里，我们在Person类中重写equal方法，用来判断对象是否完全相同，这时比较的不再是内存地址，而是比较对象的所有属性值是否相等~！

//尝试一下自己重写equal 方法
public class Equal02 {
    public static void main(String[] args) {
        Person person1 = new Person("jack",30,'男');
        Person person2 = new Person("luiso",30,'女');
        Person person3 = new Person("luiso",30,'女');
        //测试
        System.out.println(person1.equal(person2));
        System.out.println(person2.equal(person3));
    }
}
class Person{
    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;
    }
    //get set 方法
    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对象的内容是否相等，
    // 如果两个Person对象的各个属性值都一样，则返回true，反之false
    //重写 object 的equal 方法
    public boolean equal(Object obj){
        //如果形参 obj 就是调用这个方法的对象
        if (this == obj){
            return true;
        }
        //判断 obj 是不是Person类，是才有比较的必要
        if (obj instanceof Person){
            Person person = (Person) obj;//向下转型
            return this.name.equals(person.name) && this.age== person.age && this.gender== person.gender;
            //比较属性并返回
        }
        //如果不是Person类，直接返回false了
        return false;
    }
}

2.hashCode

 1)提高具有哈希结构的容器的效率!
2)两个引用，如果指向的是同一个对象，则哈希值肯定是一样的!
3)两个引用，如果指向的是不同对象，则哈希值是不一样的
4)哈希值主要根据地址号来的!，不能完全将哈希值等价于地址,
6)后面在集合中 hashcode 如果需要的话，也会重写

(1)默认用法

默认：Object 类中的 hashCode() 方法返回对象的内存地址的哈希码。

示例：如下图，对象直接调用hashCode方法，返回对象的内存地址的哈希码~！

代码

public class HashCode_01 {
    public static void main(String[] args) {
        AA a1 = new AA();
        AA a2 = new AA();
        AA a3 = a1;

        System.out.println("a1.hashCode="+a1.hashCode());
        System.out.println("a2.hashCode="+a2.hashCode());
        System.out.println("a3.hashCode="+a3.hashCode());
    }
}
class AA{};

3.toString

(1)默认用法

默认返回：全类名+@+哈希值的十六进制

示例：

(2)重写用法

重写目的：在子类中常被重写，用来输出对象的属性

重写方法：在 idea 中直接空白处 右键 点击 生成，或快捷键alt+insert；再点击toString即可

重写示例

实现代码

public class ToString_01 {
    /* toString的源码
    1.getClass().getName() 类的全类名(类名+包名)
    2.Integer.toHexString(hashCode() 将对象的hashCode值转成16进制字符串
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
     */
    public static void main(String[] args) {
        Monster monster = new Monster("小妖怪","巡山的",3000);
        //默认返回：全类名+@+哈希值的十六进制
        //重写后输出对象属性
        System.out.println(monster.toString());

        //当直接输出一个对象时，会默认调用toString()
        System.out.println(monster);

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

    //toString 常在子类中被重写，用于输出对象的属性
    //可使用快捷键 ALT+insert

    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }

    //构造器
    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }
    //
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
}

4.finalize

(1)默认用法

默认：对象被销毁前，系统自动调用该对象的finalize方法，如果不重写，什么都不会发生。

示例：

(2)重写用法

重写目的：在对象被垃圾回收之前执行一些清理操作，例如释放资源，数据库连接，打开文件...

重写示例

但是运行后却发现什么都没有，这是因为垃圾回收有自己的机制，不会立马回收，在要回收该对象时，才会执行我们重写的finalize方法~！

实现代码

//简单介绍一下 finalize 方法
//当对象被回收时，系统自动调用该对象的finalize方法
//子类可以重写该方法，做一些释放资源的操作
public class finalize_ {
    public static void main(String[] args) {
        car car1 = new car("奥迪A6");
        car1 = null;//此时，car1对象就是个垃圾，垃圾回收器会回收（销毁）对象
                    //在销毁对象前，会调用该对象的finalize方法
        //我们就可以在类中重写finalize，写一些业务逻辑（比如释放资源，数据库连接，打开文件...）
        //如果不重写，就默认调用Object类的finalize，默认处理
    }
}
class car{
    private String name;
    //构造
    public car(String name) {
        this.name = name;
    }

    //重写finalize
    @Override
    protected void finalize() throws Throwable {
        System.out.println("销毁了car"+name);
        System.out.println("释放了资源");
        //但是运行后没有出现，因为垃圾回收有自己的机制，不会立马回收
    }
}

小总结

========结束========================

求评论~

求点赞~~~！

求收藏~~~~~~！