Object类详解

equals方法

== 和 equals的对比

 
== 是一个比较运算符：
  1）== ：既可以判断基本类型，又可以判断引用类型；

  2）== ：如果判断基本类型，判断的是值是否相等；

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

public class Equals01 {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c); // ture
        System.out.println(a == b); // ture
        
        B objB = a;
        System.out.println(objB == a); // ture
    }
}
class B{}
class A extends B{}

equals 方法：
  1）是 Object类中的方法，只能判断引用类型；

  2）默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等；比如 Integer、String。

String str1 = new String("equals");
String str2 = new String("equals");
System.out.println(str1 == str2);		// false
System.out.println(str1.equals(str2));	// true


Person p1 = new Person();
p1.name = "equals";

Person p2 = new Person();
p2.name = "equals";

System.out.println(p1 == p2);	// false
// String.equals() 判断的是字符串内容是否相等
System.out.println(p1.name.equals(p2.name));	// ture
System.out.println(p1.equals(p2));	// false

hashcode 方法

  1）提高具有哈希结构的容器的效率；

  2）两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！

  3）两个引用，如果指向的是不同对象，则哈希值是不一样的；

  4）哈希值主要是根据地址号来的！不能完全将哈希值等价于地址；

  5）在集合中，hashCode 如果需要的话，也会重写；

public class HashCode {
    public static void main(String[] args) {
        AA aa1 = new AA();
        AA aa2 = new AA();
        AA aa3 = aa1;

        System.out.println("aa1.hashCode() = " + aa1.hashCode());
        System.out.println("aa2.hashCode() = " + aa2.hashCode());
        System.out.println("aa3.hashCode() = " + aa3.hashCode());
    }
}
class AA{}

运行结果：

toString方法

基本介绍：

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

// toString方法介绍、toString方法重写
public class ToString {
    public static void main(String[] args) {
        Monster monster = new Monster("小妖怪", "巡山的", 1000);

        // return getClass().getName() + "@" + Integer.toHexString(hashCode())
        // 1) getClass().getName()  全类名(包名+类名)
        // 2) Integer.toHexString(hashCode()) 将对象的hashCode值转成16进制字符串
        System.out.println(monster.toString());
    }
}

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 方法，输出对象的属性
    // 快捷键 alt + insert -> toString
    @Override
    public String toString() {  // 重写后，一般是把对象的属性值输出
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
}

重写前运行结果：

 
重写后运行结果：

 
当直接输出一个对象时，toString 方法会被默认的调用。

// 例子
	// 会默认调用 monster.toString() 方法
	System.out.println(monster);

 

finalize 方法 （新版被弃用）

 
finalize()：

  当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法；
 
  1）当对象被回收时，系统自动调用该对象的 finalize 方法；子类可以重写该方法，做出一些释放资源的操作；

  2）什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法；

  3）垃圾回收机制的调用，是由系统来决定的，也可以通过 System.gc() 主动触发垃圾回收机制。

  实际开发中，几乎不会运用 finalize，更多是了解。

public class Finalize {
    public static void main(String[] args) {
        Car bwm = new Car("宝马");

        // 这时，car对象就是一个垃圾，垃圾回收器就会回收(销毁)对象;
        // 在销毁对象前，会调用该对象的 finalize 方法;
        // 程序员就可以在 finalize 中， 写自己的业务逻辑代码(比如释放资源: 数据库连接，或者打开的文件...);
        // 如果程序员不重写 finalize，那么就会调用 Object 类的 finalize，即默认处理;
        // 如果程序员重写了 finalize，就可以实现自己的逻辑。
        bwm = null;
		
		System.gc(); // 主动调用垃圾回收器
        System.out.println("");
    }
}

class Car{
    private String name;

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

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("销毁了汽车" + name);
        System.out.println("释放了一些资源...");
    }
}

运行结果：