十、Java Object 类详解（equals方法、hashCode、toString、finalize）

---

Java Object 类详解（equals方法）

一、equals 方法

==是一个比较运算符

1. ==：既可以判断基本类型，又可以判断引用类型
2. ==：如果判断基本类型，判断的是值是否相等。 示例：int i=10，double d=10.0；
3. ==：如果判断引用类型，判断的是地址是否相等，即判断是不是同一个对象
4. equals：是Object类中的方法，只能判断引用类型
5. 默认判断的是地址值是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer，String

package com.hspedu.object_;
public class Equals01 {
public static void main(String[] args) {
A a = new A();
A b = a;
A c = b;
System.out.println(a == c);//true
System.out.println(b == c);//true
B bObj = a;
System.out.println(bObj == c);//true
int num1 = 10;
double num2 = 10.0;
System.out.println(num1 == num2);//基本数据类型，判断值是否相等
//equals 方法，源码怎么查看. //把光标放在 equals 方法，直接输入 ctrl+b
//如果你使用不了. 自己配置. 即可使用. /*
//带大家看看 Jdk 的源码 String 类的 equals 方法
//把 Object 的 equals 方法重写了,变成了比较两个字符串值是否相同
public boolean equals(Object anObject) {
	if (this == anObject) {//如果是同一个对象
		return true;//返回 true
	}
	if (anObject instanceof String) {//判断类型
		String anotherString = (String)anObject;//向下转型
		int n = value.length;
		if (n == anotherString.value.length) {//如果长度相同
		char v1[] = value;
		char v2[] = anotherString.value;
		int i = 0;
		while (n-- != 0) {//然后一个一个的比较字符
			if (v1[i] != v2[i])
			return false;
			i++;
		}
		return true;//如果两个字符串的所有字符都相等，则返回 true
	}
	}
	return false;//如果比较的不是字符串，则直接返回 false
	}
	*/ "hello".equals("abc");
	//看看 Object 类的 equals 是
	/*
	//即 Object 的 equals 方法默认就是比较对象地址是否相同
	//也就是判断两个对象是不是同一个对象. public boolean equals(Object obj) {
	return (this == obj);
	}
	*/
	/*
	//从源码可以看到 Integer 也重写了 Object 的 equals 方法, //变成了判断两个值是否相同
	public boolean equals(Object obj) {
	if (obj instanceof Integer) {
	return value == ((Integer)obj).intValue();
	}
	return false;
	}
	*/
	Integer integer1 = new Integer(1000);
	Integer integer2 = new Integer(1000);
	System.out.println(integer1 == integer2);//false
	System.out.println(integer1.equals(integer2));//true
	String str1 = new String("hspedu");
	String str2 = new String("hspedu");
	System.out.println(str1 == str2);//false
	System.out.println(str1.equals(str2));//true
	}
}
class B {}
class A extends B {}

如何重写 equals 方法

应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。

package com.hspedu.object_;
public class EqualsExercise01 {
	public static void main(String[] args) {
		Person person1 = new Person("jack", 10, '男');
		Person person2 = new Person("jack", 20, '男');
		System.out.println(person1.equals(person2));//假
	}
}
//判断两个 Person 对象的内容是否相等，
//如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false
class Person{ //extends Object
	private String name;
	private int age;
	private char gender;
	//重写 Object 的 equals 方法
	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;
		}
		//如果不是 Person ，则直接返回 false
		return false;
	}
	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;
	}
}

二、hashCode 方法

总结：

1. 提高具有哈希结构的容器的效率！
2. 提高具有哈希结构的容器的效率！
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来的！， 不能完全将哈希值等价于地址。

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.hashCode()=" + aa.hashCode());
		System.out.println("aa2.hashCode()=" + aa2.hashCode());
		System.out.println("aa3.hashCode()=" + aa3.hashCode());
	}
}
class AA {}

三、toString 方法

1. 基本介绍
   默认返回：全类名+@+哈希值的十六进制，【查看 Object 的 toString 方法】
   子类往往重写 toString 方法，用于返回对象的属性信息
2. 重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式
3. 当直接输出一个对象时，toString 方法会被默认的调用, 比如 System.out.println(monster)； 就会默认调用
   monster.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("小妖怪", "巡山的", 1000);
		System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
		System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
		System.out.println(monster); //等价 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 +
		'}';
	}
	@Override
	protected void finalize() throws Throwable {
		System.out.println("fin..");
	}
}

四、finalize 方法

1. 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作【演示】
2. 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来
   销毁该对象，在销毁该对象前，会先调用 finalize 方法。
3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制，

package com.hspedu.object_;
//演示 Finalize 的用法
public class Finalize_ {
	public static void main(String[] args) {
		Car bmw = new Car("宝马");
		//这时 car 对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前，会调用该对象的 finalize 方法
		//,程序员就可以在 finalize 中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)
		//,如果程序员不重写 finalize,那么就会调用 Object 类的 finalize, 即默认处理
		//,如果程序员重写了 finalize, 就可以实现自己的逻辑
		bmw = null;
		System.gc();//主动调用垃圾回收器
		System.out.println("程序退出了....");
	}
}
class Car {
	private String name;
	//属性, 资源。。
	public Car(String name) {
	this.name = name;
	}
	//重写 finalize
	@Override
	protected void finalize() throws Throwable {
		System.out.println("我们销毁 汽车" + name );
		System.out.println("释放了某些资源...");
	}
}

---