Java——Object类

一、Object类
（一）API概述以及Object类的概述
A:API(Application Programming Interface)
应用程序编程接口
B:Java API
就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
C:Object类概述
类层次结构的根类
所有类都直接或者间接的继承自该类
D:构造方法
public Object()
回想面向对象中为什么说：
子类的构造方法默认访问的是父类的无参构造方法
（二）Object类的hashCode()方法

public class MyTest extends Object{
    public static void main(String[] args) {
       // Application Programming Interface
        //Object 类：是所有类的顶层父类，所有类都是直接或间接继承自他
        //Object(类)
        //public int hashCode ()  //获取对象的哈希码值,不同对象的哈希码值是不一样的
        //public final Class getClass ()
        //public String toString ()
        //public boolean equals (Object obj)
        //创建Object类的对象
        Object obj = new Object();
        //使用Object类中的方法
       // System.out.println(obj);
        int i = obj.hashCode();
        System.out.println(i);
        Object obj2 = new Object();
        int i1 = obj2.hashCode();
        System.out.println(i1);
    }
}

（三）Object类的getClass()方法

public class MyTest2 {
    public static void main(String[] args) {
        //Class<?> getClass ()
        //返回此 Object 的运行时类。
        //Object.class------->当这个字节码文件加载进内存后，然后JVM会为字节码文件创建一个对象---->我可以通过getClass()方法获取这个字节码文件对象
        Object obj = new Object();
        Class aClass = obj.getClass();  //Class 表示字节码文件类
        Object obj2 = new Object();
        Class aClass1 = obj2.getClass();
        System.out.println(obj == obj2); //false
       // Object.class--->字节码文件的对象
        System.out.println(aClass == aClass1);//true
        //反射机制---->需要用到字节码文件对象
    }
}

（四）Object类的toString()方法

public class MyTest {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj);
        String s = obj.toString(); //获取该对象的16进制地址值的字符串表现形式
        System.out.println(s);
        String name = obj.getClass().getName();
        System.out.println(name);
        name=name+"@"+Integer.toHexString(obj.hashCode());
        System.out.println(name);
        //public String toString () {
        //    return this.getClass().getName() + "@" + Integer.toHexString(hashCode());
        //}
        Student student = new Student();
        System.out.println(student.toString());
    }
}
class Student extends Object{}

（五）Object类的equals()方法

public class MyTest {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("张三", 23);
        Teacher t2 = new Teacher("张三", 23);
        System.out.println(t1 == t2);
        System.out.println(t1.equals(t2));
    }
}
class Teacher {
    private String name;
    private int age;
    public Teacher() {
    }
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        // 判断 o 是否是teacher类型
        //if(o instanceof Teacher){
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        Teacher teacher = (Teacher) o;
        return age == teacher.age && Objects.equals(name, teacher.name);
    }
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

（六）Object类的clone() 方法
clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
对象的浅克隆:浅克隆和深克隆
​ 使用clone()方法采用的是浅克隆的方式
对象浅克隆要注意的细节：

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2. Cloneable接口只不过是一个标识接口而已，没有任何方法。
3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把
   另外一个对象也克隆一份。
4. 对象的浅克隆也不会调用到构造方法的。
   对象的深克隆(后面讲)：采用IO流来实现 使用 ObjectOutputStream 将对象写入文件中,然后再用ObjectInputStream读取回来
   //克隆时 两点需要注意
   //注意 protected Object clone() 是一个受保护的方法，直接调用不到，我们可以让这个类，重写一下，重写逻辑还是用父类的克隆逻辑
   // 你要克隆这个类的对象，那这个类必须要实现一个Cloneable这个标记接口，克隆才会成功
   克隆：浅克隆 ：当你克隆的对象中，有另外一个对象，那么你克隆过来的对象中，只是克隆了另外一个对象的地址值
   深克隆：序列化流可以进行深克隆

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        //protected Object clone ()
        //创建并返回此对象的一个副本。
        Dog dog = new Dog("小白",3);
        System.out.println(dog.name);
        System.out.println(dog.age);
        //克隆对象
        Dog dog2 = (Dog) dog.clone();
        dog2.name="旺财";
        System.out.println(dog2.name);
        System.out.println(dog2.age);
    }
}
//Cloneable 你想要克隆这个类的对象，需要让这个类实现一个 Cloneable 接口
//Cloneable 这个接口里面没有任何抽象方法，他就是一个标记接口
class Dog extends Object implements Cloneable{
    public String name;
    public int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    protected Object clone() throws CloneNotSupportedException {
        //还是去调用父类的克隆逻辑
        return super.clone();
    }
}