面向对象（中级） - Object类 - 《Java 学习笔记》

一：equals方法
三：hashcode方法
五：finalize方法

一：equals方法

1：==和equals的对比

==：既可以判断基本类型，又可以判断引用类型
==：如果判断基本类型，判断的是值是否相等。示例:int i=10; double d=10.0;

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

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：是Object类中的方法，只能判断引用类型，

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

//重写了object中的equals方法
public boolean equals(Object anObject) { 
 if (this == anObject) { //如果是同一个对象
     return 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;
     }
 }
 return false;
}

```java public boolean equals(Object obj) { if (obj instanceof Integer) {

 return value == ((Integer)obj).intValue();

} return false; }

Integer integer = new Integer(1000); Integer integer1 = new Integer(1000); System.out.println(integer == integer1);//是false //但是用equals方法判断的话，是true，因为已经重写过了，有判断地址改为判断值 integer.equals(integer1); //true

String str1 = new String( “hspedu”); String str2 = new String( “hspedu “); System.out.println(str1 =str2);//F System.out.println(str1.equals(str2));//T


5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如lnteger,String【看看string 和 Integer的equals源代码】
<a name="XdohN"></a>
### 二：如何重写equals方法
<a name="Ypn7Z"></a>
#### 1：应用实例
> **判断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样，则返回 true，反之 false。**
两种写法
```java
public boolean equals(Object obj) {
    if (this == obj){
        return true;
    }
    if (obj instanceof Person){
        Person p = (Person)obj;
        return this.name == p.name && this.age == p.age;
    }
    return false;
}

    public boolean equals(Person obj) {
        if (this == obj){
            return true;
        }else {
            Person p = (Person)obj;
            return this.name == p.name && this.age == p.age;
        }
    }

2：应用实例2

Person_ p1 = new Person_();
p1.name = "hspedu";
Person_ p2 = new Person_(); 
p2.name = "hspedu";
System.out.println(p1==p2); //False 
System.out.println(p1.name .equals( p2.name));//T 
System.out.println(p1.equals(p2));//False
String s1 = new String("asdf");
String s2 = new String("asdf"); 
System.out.println(s1.equals(s2));//T
System.out.println(s1==s2); //F

3：应用实例3

int it = 65; 
float fl = 65.0f;
System.out.println(“65 和 65.0f是否相等？” + (it == fl));//T
System.out.println(“65 和‘A’是否相等？” + (it == ch1));//T 
System.out.println(“12 和 ch2 是否相等？” + (12 == ch2));//T
String str1 = new String("hello"); 
String str2 = new String("hello"); 
System.out.println("str1 和 str2 是否相等？"+ (str1 == str2)); //F
System.out.println(“str1 是否 equals str2？”+(str1.equals(str2)));//T
System.out.println(“hello” == new java.sql.Date()); //编译错误

三：hashcode方法

1：基本介绍

返回该对象的哈希值，支持此方法是为了提高哈希表的性能。

2：作用

提高具有哈希结构的容器的效率！
两个引用，如果指向的是同一个队形，则哈希值肯定是一样的！
两个引用，如果指向的是不同对象，则哈希值是不一样的。 ```java Person sakura = new Person(“sakura1”, 18); Person sakura1 = new Person(“sakura”, 18);

Person sakura2 = sakura;

System.out.println(sakura.hashCode()); System.out.println(sakura1.hashCode()); System.out.println(sakura2.hashCode());


- 哈希值主要根据地址好来的不能完全讲哈希值等价与地址
<a name="kluEV"></a>
### 四：toString方法
<a name="uIJmX"></a>
#### 1：基本介绍
**默认返回：全类名+@+哈希值的十六进制，【查看Object 的 toString 方法】**
```java
//getClass() + getname() : 全类名
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Person sakura = new Person("sakura1", 18);
System.out.println(sakura.toString());
//如果没有重写，则默认会输出全类名+@+哈希值的十六进制
//Date0802.Test00.Person@1b6d3586

子类往往重写toString方法，用于返回对象的属性信息

2：重写toString()方法

打印对象或拼接对象时，都会自动调用该对象的 toString 形式.

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

当直接输出一个对象时，toString方法会默认的调用
```
//两者等价
System.out.println(sakura.toString());
System.out.println(sakura);
```
五：finalize方法

当对象被回收时，系统自动调用该对象的 finalize方法。子类可以重写该方法，做一些释放资源的操作 ```java Person p1 = new Person(); p1 = null //并不是置空之后局立即调用finalize，在jvm中的垃圾回收算法决定什么时候回收

@Override protected void finalize() throws Throwable { System.out.println(“我们销毁人” + name ); System.out.println(“释放了某些资源…”); } ```

什么时候被回收:当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制，测试：Car [name]

Object类