Object类是Java语言中的根类，就是所有类的父类，如果一个类没有特别指定的父类，那么默认这个类继承于Object类。
Object类中的hashCode()方法
public int hashCode()方法：
返回该对象的哈希码值

package org.jimmy.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo {

}
class test{
    public static void main(String[] args) {
        MyDemo my = new MyDemo();
        int i = my.hashCode();
        System.out.println(i);
    }
}
356573597

getclass()方法
public final Class getclass():
返回该类的运行时类

package org.jimmy.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo {

}
class test{
    public static void main(String[] args) {
        MyDemo my = new MyDemo();
        Class<? extends MyDemo> aClass = my.getClass();
        System.out.println(aClass);
    }
}
class org.jimmy.demo.MyDemo

equals()方法
判断两个对象的引用是否相同

package org.jimmy.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo {

}
class test{
    public static void main(String[] args) {
        MyDemo my = new MyDemo();
        MyDemo my1 = new MyDemo();
        System.out.println(my.equals(my1));
        my=my1;
        System.out.println(my.equals(my1));
    }
}
false
true

equals方法一般建议重写，因为比较两个对象的引用没有什么意义
我们可以通过instanceof关键字来提高equals的健壮性，判断该对象是否为类的实例化
tostring()方法
public String tostring()：
返回该对象的字符串显示
一般返回字符串显示没有意义，所以建议重写该方法，将该类的成员变量返回

package org.jimmy.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo {
    public int age;

    public MyDemo(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "MyDemo{" +
                "age=" + age +
                '}';
    }
}
class test{
    public static void main(String[] args) {
        MyDemo my = new MyDemo(5);
        System.out.println(my.toString());

    }
}
MyDemo{age=5}

clone()方法
在使用clone()方法时，要注意，clone()方法权限修饰符是受保护的，所以我们要重写该方法，将修饰符改成public，对象的克隆分为深克隆和浅克隆，在这里我们只研究浅克隆

浅克隆在调用时也要注意以下几点：
a.一个对象要克隆时，它的类必须要实现cloneable接口，该接口中没有任何内容，只是相当于一个标识接口
b.一个对象，在克隆另一个对象时，如果该对象中有另一个类的对象，那么，你只是克隆的是另一个对象的地址值而已，并不是克隆了一份这个对象。
c.对象的浅克隆也不会调用到构造方法的

package org.jimmy.demo;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo implements Cloneable {
    public int age;

    public MyDemo(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "MyDemo{" +
                "age=" + age +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}
class test{
    public static void main(String[] args) throws CloneNotSupportedException {
        MyDemo my = new MyDemo(5);
        MyDemo clone = (MyDemo) my.clone();
        System.out.println(clone);

    }
}
MyDemo{age=5}

我们在类中加入另一个类的对象再来测试一下

package org.jimmy.demo;

import java.util.Objects;

/**
 * @Author: Administrator
 * @CreateTime: 2018-12-25 18:31
 */
public class MyDemo implements Cloneable {
    public int age;
    public MyTest test;

    public MyDemo(int age, MyTest test) {
        this.age = age;
        this.test = test;
    }

    @Override
    public String toString() {
        return "MyDemo{" +
                "age=" + age +
                ", test=" + test +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyDemo myDemo = (MyDemo) o;
        return age == myDemo.age &&
                Objects.equals(test, myDemo.test);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, test);
    }
}
class MyTest{
    public String name;

    public MyTest(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MyTest{" +
                "name='" + name + '\'' +
                '}';
    }
}
class test{
    public static void main(String[] args) throws CloneNotSupportedException {
        MyTest test = new MyTest("张三");
        MyDemo my = new MyDemo(5,test);
        MyDemo c1 = (MyDemo) my.clone();
        System.out.println(c1);
        c1.test.name="李四";
        System.out.println(my);
        System.out.println(c1);
        System.out.println(c1==my);
        System.out.println(c1.equals(my));
    }
}
MyDemo{age=5, test=MyTest{name='张三'}}
MyDemo{age=5, test=MyTest{name='李四'}}
MyDemo{age=5, test=MyTest{name='李四'}}
false
true

可以看出，在类中的另一个类创建对象后，该对象改变他的成员变量，MyDemo的对象和他的克隆对象中的该变量也会改变，如果我们只改变一个对象中的age变量，那么只是这个对象的变量发生改变，同时我们也重写了equals()方法，来对比==和equals()方法。