Object类

1.Object类

Object类是Java中所有类的基类

学习Object类就是在学习他的方法

构造方法:

可以直接实例化

Object()

只需要学习三个方法

String	toString()返回对象的字符串表示形式

public String toString()

返回对象的字符串表示形式。 一般来说， toString方法返回一个“textually代表”这个对象的字符串。 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。

该toString类方法Object返回一个由其中的对象是一个实例，该符号字符的类的名称的字符串@` ”和对象的哈希码(内存地址)的无符号的十六进制表示。 换句话说，这个方法返回一个等于下列值的字符串：

getClass().getName() + '@' + Integer.toHexString(hashCode()) 

• 结果

  对象的字符串表示形式。

package com.qfedu.a_object;
class Person {
    String name;
    int age;
    //person类是Object类子类不？ 是！！！
​
​
    //
    @Override
    public String toString() {
        System.out.println("123");
        return
                "name=\"" + name + '\"' +
                ", age=" + age
                ;
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Object obj = new Object();
        Person person = new Person();
        System.out.println(person);
​
    }
}
​

boolean	equals(Object obj)指示一些其他对象是否等于此。

boolean eaqual(Object obj);

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

Object 类下面的方法比较是两个对象的地址。不看内容的

为啥String类下面的equals方法比较的是内容呢？String类继承了Object

equals方法重写了Object类下面的。为啥重写？

当父类的需求，满足不了子类的需求的时候要重写父类的方法

需求：比较两个对象的内容是否一样？ 如果两个对象的内容一样返回一个true。反之返回false

package com.qfedu.a_object;
​
import java.util.Objects;
​
class Student {
    String name;
    int age;
​
    public Student(String name, int age) {
​
        this.name = name;
        this.age = age;
    }
    //重写equlas,要求去比较内容，如果内容一样的额话，返回true
​
​
    //stu1.equals(stu2)
    //stu2赋值给了 o  向上转型 Object o =new Student();
    @Override
    public boolean equals(Object o) {
        if (this == o) {//比较是地址
            return true;
        }
        //如果地址不一样的话，再去比较内容，如果内容一样也返回true
        if (o instanceof Student) {
            //才去比较值 name  age
            Student stu = (Student)o;//向下转型
            //stu1.equals(stu2)  stu就是stu2  this 是stu1
            return stu.age == this.age && stu.name.equals(this.name);
​
        }
        return false;
    }
​
​
}
public class Demo2 {
    public static void main(String[] args) {
        Student stu1 = new Student("老邢", 89);
        Student stu2 = new Student("老邢", 89);
        //stu1是Object类子类，用的是object 类面的equals方法
        //Object类下面的equals方法比较是 地址  this==obj
        //System.out.println(stu1.equals(stu2));//false
        //现在我的需求是当两个对象的内容一致的时候返回的额是true
        //内容不一样的时候，返回是false
        //就意味着Object类的equals方法已经满足不了Student类的需求了
        //咋解决？ 重写equals方法
        System.out.println(stu1.equals(stu2));//true
    }
}
​

package com.qfedu.a_object;
​
import java.util.Objects;
​
class Student1 {
    String name;
    int age;
​
    public Student1(String name, int age) {
​
        this.name = name;
        this.age = age;
    }
    //重写equlas,要求去比较内容，如果内容一样的额话，返回true
​
​
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()){
            return false;
        }
        Student1 student1 = (Student1) o;
        return age == student1.age && Objects.equals(name, student1.name);
    }
​
​
}
public class Demo3 {
    public static void main(String[] args) {
        Student1 stu1 = new Student1("老邢", 89);
        Student1 stu2 = new Student1("老邢", 89);
        //stu1是Object类子类，用的是object 类面的equals方法
        //Object类下面的equals方法比较是 地址  this==obj
        //System.out.println(stu1.equals(stu2));//false
        //现在我的需求是当两个对象的内容一致的时候返回的额是true
        //内容不一样的时候，返回是false
        //就意味着Object类的equals方法已经满足不了Student1类的需求了
        //咋解决？ 重写equals方法
        System.out.println(stu1.equals(stu2));//true
    }
}
​

int hashCode();

哈希码值：在Object类下面，将内存地址（十六进制的值）转为十进制的值，此时这个十进制的值就叫hash码。

返回对象的哈希码值。 支持这种方法是为了散列表，如HashMap提供的那样 。

hashCode的注意事项是：

• 只要在执行Java应用程序时多次在同一个对象上调用该方法， hashCode方法必须始终返回相同的整数，前提是修改了对象中equals比较中的信息。 该整数不需要从一个应用程序的执行到相同应用程序的另一个执行保持一致。

• 如果根据equals(Object)方法两个对象相等，则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。

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

尽可能多的合理实用，由类别Object定义的hashCode方法确实为不同对象返回不同的整数。 （hash码的值通常通过将对象的内部地址转换为整数来实现，但Java的编程语言不需要此实现技术。）

package com.qfedu.a_object;
​
class Cat {}
public class Demo4 {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        Cat cat2 = new Cat();
        System.out.println(cat1.hashCode());
        System.out.println(cat2.hashCode());
        String str = new String("a");
        String str1 = new String("b");
        String str2 = new String("a");
        //现在真他娘的尴尬，Object类的hash值是内存地址十进制的转换
        //只要你内U存地址不一样，hash值一定不一样
        //但是你看看str和str2 ，内存地址不一样，但是
        //hash值是一样的？咋回事？在String类中重写了hashCode
        //方法
        System.out.println(str.hashCode());//97
        System.out.println(str1.hashCode());//98
        System.out.println(str2.hashCode());//97
​
​
​
    }
​
}
​

请注意，无论何时重写equals方法，通常需要重写hashCode方法，以便维护hashCode方法的通用合同，该方法规定相等的对象必须具有相等的哈希码

package com.qfedu.a_object;
​
import java.util.Objects;
​
class Dog {
    int id;
    String name;
​
    public Dog(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public boolean equals (Object o) {
        if (this ==  o) {
            return  true;
        }
        if (o instanceof Dog) {
            Dog dog = (Dog)o;
            return this.id == dog.id && dog.name.equals(this.name);
        }
        return false;
    }
​
    @Override
    public int hashCode() {
        return name.hashCode() + id;
    }
}
public class Demo5 {
    public static void main(String[] args) {
        Dog dog1 = new Dog( 3, "a");
        Dog dog2 = new Dog( 2, "b");
        //现在关注的是内容，如果内容一样 调用equals方法的时候
        //必须返回一个true
        System.out.println(dog1.equals(dog2));//true
        //此时这个两个对象的hash值一样不一样？因为内存地址不一样的
        System.out.println(dog1.hashCode());
        System.out.println(dog2.hashCode());
        //现在hashCode不一样咋办？ 重写hashCode即可
//如果根据equals(Object)方法两个对象相等，
// 则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
        //如果两个对象的hash值一样，对象是不一定一样的。但是如果两个对象相等
        //那么hash值一定相等
    }
}
​

package com.qfedu.a_object;
​
import java.util.Objects;
​
class Panda {
    int id;
    String name;
​
    public Panda(int id, String name) {
        this.id = id;
        this.name = name;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Panda panda = (Panda) o;
        return id == panda.id && Objects.equals(name, panda.name);
    }
​
    @Override
    public int hashCode() {
        return id;
    }
}
public class Demo6 {
    public static void main(String[] args) {
        String str1 = new String("ab");
        String str2 = new String("a");
        System.out.println(str1.equals(str2));//true
        //31 * 97+ 98
        System.out.println(str1.hashCode());//3105
        System.out.println(str2.hashCode());
        //STring类下面的hashCode重写的Object类下面的
​
        Integer i1 = new Integer(45);
        Integer i2 = new Integer(45);
        System.out.println(i1 == i2);//false
        System.out.println(i1.equals(i2));//true
        //大胆猜测一下 hash值是啥？
        System.out.println(i1.hashCode());
        System.out.println(i2.hashCode());
​
        Panda panda1 = new Panda(67, "狗蛋");
        Panda panda2 = new Panda(67, "狗蛋");
        System.out.println(panda2.equals(panda1));
        System.out.println(panda1.hashCode());
        System.out.println(panda2.hashCode());
    }
}
​