Object：java.lang 核心包不需要引入
1. getClass():返回此 Object 的运行时类。
Object o = new Object(); System.out.println(o.getClass()); //class java.lang.Object
2. toString():返回该对象的字符串表示形式。
getClass().getName() + '@' + Integer.toHexString(hashCode())
把对象以文本方式展示，类名@无符号十六进制的 哈希码值(经过压缩处理的对象地址值)；
日常开发中主要用于把对象转字符串。Object o = new Object(); System.out.println(o); //java.lang.Object@15db9742
3. hashcode():判断对象不相等（比较高效）。
对象相等（通过equals（）判断）则哈希值一定相等，
哈希值不相等则对象一定不相等。String str1 = "通话"; String str2 = "重地"; System.out.println(String.format("str1:%d|str2:%d", str1.hashCode(),str2.hashCode())); System.out.println(str1.equals(str2)); //str1:1179395|str2:1179395 //false 两个对象的hashCode相同，但是equals不一定相同
4. equals():证明两个对象是否相等。
子类使用必须重写，而且必须要重写hashcode 。
未重写时本质上也是==判断，判断引用类型时，比较的是引用地址。String s1 = "老王"; String s2 = "老王"; String s3 = new String("老王"); System.out.println(s1==s2); //true s1、s2值相同存在常量池中，地址肯定一样 System.out.println(s1==s3); //false s3是新new出来的对象，储存在堆中，地址和他俩不同 System.out.println(s2==s3); //true //String方法重写了equals（值比较），s1 s2 s3值相同所以都是true System.out.println(s1.equals(s2)); //true System.out.println(s1.equals(s2)); //true System.out.println(s2.equals(s3)); //true
5. finalize():当对象被拉进回收器回收前调用.
子类必须重写，可以通过
System.gc();手动触发垃圾回收器工作。
- 栗子：创建User类（姓名、密码），重写equals()、ashcode()、finalize()等方法，实现根据姓名和密码判断对象是否相同。
```java
public class TestObject {
public static void main(String[] args) {
User u1 = new User("老王","123");
User u2 = new User("老王","123");
System.out.println(u1.hashCode());
System.out.println(u2.hashCode()); //重写equals、hashCode后相同对象具有相同哈希值
System.out.println(u1==u2); //通过引用地址进行判断
System.out.println(u1.equals(u2)); //未重写时也是判断引用地址，重写后根据姓名和密码判断
u2 = null;
System.gc();
}
}
class User{
private String Name ;
private String password;
public User(String name, String password) {
super();
Name = name;
this.password = password;
}
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((Name == null) ? 0 : Name.hashCode());
result = prime * result + ((password == null) ? 0 : password.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) //引用地址相同返回true
return true;
if (obj == null) //为空直接返回false
return false;
if (getClass() != obj.getClass()) //类名不相同返回false
return false;
User other = (User) obj;
if (Name == null) {
if (other.Name != null)
return false;
} else if (!Name.equals(other.Name))
return false;
if (password == null) {
if (other.password != null)
return false;
} else if (!password.equals(other.password))
return false;
return true;
}
@Override
protected void finalize() throws Throwable {
// TODO 自动生成的方法存根
super.finalize();
System.out.println("俺马上就要被拉进垃圾回收器了！");
}
}
```
- 考：
1. 为什么重写equals方法后，还要重写hashCode方法？
因为必须保证重写后的equals方法认定相同的两个对象具有相同的哈希值（hashCode方法的重写原则）。hashCode 的常规协定是：
在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行equals 比较时所用的信息没有被修改。程序下一次执行时该整数无需保持一致。
如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用hashCode 方法不要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
2. final、finally、finalize的区别是什么？
final：是修饰符
修饰类：最终类，此类不能被继承。
修饰方法：此方法不能被重写。
修饰变量：变量为常量，不能被修改，只能使用。finally：是异常处理try{}catch{}finally{}最后部分的语。
finally{}表示无论异常是否发生该语句块中代码一定执行一次。finalize：是Object类中的一个公有方法
在垃圾回收器执行的时候会调用被回收对象的此方法。通常用来释放资源。
3. equals()和==的区别是什么？
==：根据数据类型的不同效果也不一样。
基本数据类型：比较的是值是否相同。
引用数据类型：比较的是引用是否相同。equals()：是Object的一个方法
本质上也是==，但是String、Integer类等重写了此方法，把它变成了值比较。
用户可根据需求重写此方法，重新定义判断相等的标准。
（例如：通过用户名和密码等判断是否为同一个用户）
