常用方法Object(类)

public int hashCode()
    public final Class getClass()
    public String toString()
    public boolean equals(Object obj)

一、概述

Java API

Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用

Object类

类层次结构的根类，所有类都直接或间接的继承自该类

Object类构造方法

public Object()，子类的构造方法默认访问父类的无参构造

二、Object类的hashCode()方法

public int hashCode()

返回该对象的哈希码值，默认情况下，该方法会根据对象的地址来计算
不同对象的，hashCode()一般来说不会相同。但同一个对象的hashCode()值肯定相同
哈希码值不是对象的实际地址，相当于一个逻辑地址值
案例

public static void main(String[] args) {
    int i = new Object().hashCode();
    int i1 = new Object().hashCode();
    System.out.println(i);
    System.out.println(i1);
}
//输出：
356573597
1735600054

三、Object类的getClass()方法

public final Class getClass()
返回该类的字节码文件对象

案例

public static void main(String[] args) {
    Object o = new Object();
    Object o1 = new Object();
    Class<?> aClass = o.getClass(); //字节码文件对象
    Class<?> aClass1 = o1.getClass();
    String name = aClass.getName();
    String name1 = aClass1.getName();
    System.out.println(name);
    System.out.println(name1);
}
//输出：
java.lang.Object
java.lang.Object

四、Object类的toString()方法

public String toString()

返回该对象的地址值的字符串表现形式，一般重写，输出一个对象则默认在对象名后有隐式的.toString()

源码

public String toString() {
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
案例1
public static void main(String[] args) {
        Object obj = new Object();
        String s = obj.toString(); //获取该对象的地址值的字符串表现形式
        System.out.println(s);
        Object o = new Object();
        System.out.println(o.toString());
    }
    //输出：
    java.lang.Object@1540e19d
    java.lang.Object@677327b6
案例2
public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("张三", 23);
        System.out.println(teacher);
```
}
```
}
class Teacher{
    private String name;
    private int age;
```
public Teacher(String name, int age) {
    this.name = name;
    this.age = age;
}
```
//重写toSring方法
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//输出：Teacher{name=‘张三’, age=23}

五、Object类的equals()方法

public boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”,默认情况下比较的是对象的引用是否相同,由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等

源码

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

案例

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        Object obj2 = new Object();
        // boolean equals (Object obj) 判断两个对象的地址值是否相同
        System.out.println(obj == obj2); //false
        boolean b = obj.equals(obj2); 
        System.out.println(b); //b=true
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("张三", 23);
        System.out.println(s1 == s2);//false
        //System.out.println(s1.equals(s2)); //true
        //s1.equals(s2) 比较两个对象的地址值，是否相同，对我来说意义不大，我认为的是，只要两个对象的成员变量的值一样，我就认为这两个对象一样。那么我就得重写父类的equals()方法，让他去比较两个对象的成员变量的值是否相同
    boolean b1 = s1.equals(new Teacher());//ClassCastException 类型转换异常
    System.out.println(b1);//false
    boolean b2 = s1.equals(s1);
    System.out.println(b2);//true
}
}
class Student {
    private String name;
    private int age;
public Student(String name, int age) {
    this.name = name;
    this.age = age;
}
@Override
public boolean equals(Object obj) {
    //如果是自己跟自己比，直接就是true
    if (this == obj) {
        return true;
    }
    // 让他去比较两个对象的成员变量的值是否相同
    if (!(obj instanceof Student)) {
        return false;
    }
    //向下转型
    Student stu = (Student) obj;
    return this.name.equals(stu.name) && this.age == stu.age;
}
}

equals()方法重写优化

public boolean equals(Object o) {
    if (this == o) {
        return true;
    }
    if (o == null || getClass() != o.getClass()) {
        return false;
    }
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
}

六、Object类的clone() 方法(浅克隆)

protected Object clone () 创建并返回此对象的一个副本

案例
public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
      //  protected Object clone () 创建并返回此对象的一个副本。
        Dog dog = new Dog();
        System.out.println(dog);
        dog.name="小黑";
        dog.age=10;
        System.out.println(dog.name);//小黑
        System.out.println(dog.age);//10
    Dog dog1= (Dog) dog.clone();//需强制转型
    System.out.println(dog1);
    System.out.println(dog1.name);//小黑
    System.out.println(dog1.age); //10
    //CloneNotSupportedException 克隆不支持异常
    Dog dog2 = new Dog();
    Dog dog3 = (Dog) dog2.clone();
    System.out.println(dog3.name);//小白
    System.out.println(dog3.age);//23
}
}
//此类实现了 Cloneable 接口，以指示 Object.clone()方法可以合法地对该类实例进行按字段复制。
//如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出CloneNotSupportedException 异常。
//Cloneable 没有任何抽象方法的接口，是一个标记接口
class Dog extends Object implements Cloneable{
    String name="小白";
    int age=23;
@Override
protected Object clone() throws CloneNotSupportedException {
    //调用父类的clone功能
    return super.clone();
}