Object类

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 的常规协定是：

1. 在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行equals 比较时所用的信息没有被修改。程序下一次执行时该整数无需保持一致。

2. 如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。

3. 如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用hashCode 方法不要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

---

2. final、finally、finalize的区别是什么？
final：是修饰符
    修饰类：最终类，此类不能被继承。
    修饰方法：此方法不能被重写。
    修饰变量：变量为常量，不能被修改，只能使用。

finally：是异常处理try{}catch{}finally{}最后部分的语。
    finally{}表示无论异常是否发生该语句块中代码一定执行一次。

finalize：是Object类中的一个公有方法
    在垃圾回收器执行的时候会调用被回收对象的此方法。通常用来释放资源。

---

3. equals()和==的区别是什么？
==：根据数据类型的不同效果也不一样。
    基本数据类型：比较的是值是否相同。
    引用数据类型：比较的是引用是否相同。

equals()：是Object的一个方法
    本质上也是==，但是String、Integer类等重写了此方法，把它变成了值比较。
    用户可根据需求重写此方法，重新定义判断相等的标准。
（例如：通过用户名和密码等判断是否为同一个用户）