JavaSE学习：第十二章、Object类

1、定义：

Object类是所有类的超类，所有对象（包括数组）都实现了这个类的方法。

2、object类常用方法：

1、equals方法：

**1、：比较运算符**==

1、==：是一个比较运算符：
a、如果判断基本数据类型，判断的是值是否相等。
b、如果判断引用数据类型，判断的是地址值是否相等。

package com.hsf.extends_.object_;

public class test {
    public static void main(String[] args) {
        int a = 10;
        double b = 10.0;
        System.out.println(a == b);  // true

        A a1 = new A();
        A a2 = a1;  // 让a2也指向了a1
        System.out.println(a1 == a2);  // true
        A a3 = a2;
        System.out.println(a3 == a1);  // true
    }
}

class A {}
class B {}

2、equals方法

equals：是object类中的方法，只能判断引用类型，默认是判断地址值是否相等，但是子类往往会重写该方法（子类：如string、integer等，到时object的子类，他们会重写该方法）

String重写equals方法，用于判断值是否相等

// Object是所有类的父类，因此是向下转型
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;
    }

Integer重写equals方法：用于判断值是否相等

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

练习题：

int i = 65;
float f1 = 65.0f;
sout(if == f1); // true;

char ch1 = 'A';
char ch2 = 12;
sout(it == ch1);  // true
sout(12 == ch2);  // true

String str1 = new String("hello");
String str2 = new String("hello");
sout(str == str2); // false

sout(str1.equals(str2)); // true 只要是字符串，比较的都是值是否相等。

自己重写equals方法，判断两个对象的值是否一样

public class test {
    public static void main(String[] args) {
        Person person1 = new Person("jack", 20, '男');
        Person person2 = new Person("jack", 20, '男');
        System.out.println(person1.judge(person2));

    }
}

package com.hsf.extends_.object_;

public class Person {
    String name;
    int age;
    char sex;

    public Person(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

       public boolean judge(Object obj) {
        /*
         * this:person1：哪个对象调用这个方法，那么this就指向谁
         * person1.judge(person1)
         * */
        if (this == obj) {
            return true;
        }
        /*
        * obj是传入的参数，person是调用的方法。
        * person1.judge(son)  obj = son  person = person1
        * */
        if (obj instanceof Person) {  // 如果你传入类是person类，那么就可以进行比较
            /*
             * 形参obj是父类，如果要访问person里面的属性，要向下转型。
             * Obj obj = new Person;
             * Person p = (Person)obj;
             * */
            /*
            * Person1 p = (Person1)son
            * */
             // Object是所有类的父类，因此是向下转型：
             // 所有类都是Object的子类，因此有潜在的：Person extends Object 
             // 潜在的：Object obj = new Person()
            Person p = (Person)obj; // 要取得传进来对象的属性，必须向下转型。
//            Object obj =(Object) person;
            return this.name.equals(p.name) && this.age == p.age && this.sex == p.sex;
        }
        return false;   // 如果你传入类不是person类，直接返回FALSE


    }
}

2、hashCode方法：

1、定义：

该方法会针对不同对象返回不同的整数（这一般是通过将该对象的内存地址转换为一个整数来实现的。）

2、小结：

1、hashcode可以提高具有哈希结构容器的效率。
2、两个引用，如果指向的是同一个对象，则哈希值是一样的。
3、不能完全将哈希值等价于地址。
4、hachCode如果需要，也会重写。

AA aa = new AA();
sout(aa.hashCode);

3、toString()方法：

1、源码

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

 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

sout(person1.toString());  // com.hsf.extends_.object_.Person@1b6d3586

2、子类往往重写toString方法，用于打印对象或拼接对象。

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

3、当直接输出一个对象时，toString()方法会被默认调用：

sout(person1);

/*
Person{name='jack', age=20, sex=男}
*/