Object中clone,toString和getClass方法的分析（画图深度剖析浅克隆，深克隆）

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

getClass()获取类对象
getName()以String形式返回类对象的名称
Integer.toHexString(hashCode())以对象的哈希码为参数，以16进制无符号整数形式返回此哈希码的字符串表示形式；
在实体类中我们一般会重写toString方法。
（1、在大量代码调试的时候它的作用就凸显了，可以很方便的查看这个实体类含带的属性的值，无需一层层翻看实体类的属性找值了。有些复杂的实体变量很难在调试的时候找到它含带的值，这时候toString()就显得很有用，容易监控实体类属性值变动和走向。
2、在输出显示实体类的易查看。实体类可以像String一样方便的输出显示。

clone方法的分析

为什么要克隆对象？？？直接new出来一个不好吗？？？
克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。
clone方法克隆的对象跟原来的对象同时独立存在的。
先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。
浅克隆：

1. 被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常)。

2. 该接口为标记接口，接口里只有一句话，不含任何方法。

3. 覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象。

public class Student  implements  Cloneable{
    private int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

   @Override
   public Object clone() {
       Student stu = null;//先开辟出来一块内存，避免指向内存堆里同一个对象（我是这么理解的，先开辟内存，再把克隆过来的给他）
       try{
           stu = (Student)super.clone();
           //super.clone();调用父类clone方法，父类调用的是本地底层方法了。
       }catch(CloneNotSupportedException e) {
           e.printStackTrace();
       }
       return stu;
   }
}

 public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = (Student)stu1.clone();

        System.out.println("学生1:" + stu1.getNumber());
        System.out.println("学生2:" + stu2.getNumber());

        stu2.setNumber(54321);

        System.out.println("学生1:" + stu1.getNumber());
        System.out.println("学生2:" + stu2.getNumber());
    }

深克隆
在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。
简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量（值类型，引用类型）也将复制。
例子说明：

public class Address {
    private String add;
    public void setAdd(String add) {
        this.add = add;
    }
    public String getAdd() {
        return add;
    }
}

public class Student  implements  Cloneable{
    private int number;
    //浅克隆的时候只有值类型，并没有引用类型（Address类型）
    private Address address;
    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

    @Override
   public Object clone() {
       Student stu = null;
       try{
           stu = (Student)super.clone();
       }catch(CloneNotSupportedException e) {
           e.printStackTrace();
       }
       return stu;
   }
}

 public static void main(String[] args) {
        Address address=new Address();
        address.setAddress("承德");
        Student stu1 = new Student();
        stu1.setNumber(1);
        stu1.setAddress(address);
        Student stu2 = (Student)stu1.clone();

        System.out.println("学生1:   " + stu1.getNumber()+" 学生1地址："+stu1.getAddress().getAdd());
        System.out.println("克隆学生: " + stu2.getNumber()+" 学生2地址："+stu1.getAddress().getAdd());

        stu2.setNumber(2);
        //当我们把地址改了，两个学生的地址都发生了改变。
        //原因是浅复制只是复制了add变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。
        address.setAdd("三河");

        System.out.println("学生1:   " + stu1.getNumber()+" 学生1地址："+stu1.getAddress().getAdd());
        System.out.println("克隆学生: " + stu2.getNumber()+" 学生2地址："+stu1.getAddress().getAdd());
    }

对应的程序输出结果：

正确做法:

public class Address implements Cloneable {
    private String add;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

    @Override
    public Object clone() {
        Address addr = null;
        try {
            addr = (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return addr;
    }
}

public class Student implements Cloneable {
    private int number;
    private Address addr;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public void setAddress(Address address) {
        this.addr = address;
    }

    public Address getAddress() {
        return addr;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try {
            stu = (Student) super.clone();   //浅复制
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        stu.addr = (Address) addr.clone();   //深度复制
        return stu;
    }
}

public class Two {
    public static void main(String[] args) {
        Address address=new Address();
        address.setAdd("承德");
        Student stu1 = new Student();
        stu1.setNumber(1);
        stu1.setAddress(address);
        Student stu2 = (Student)stu1.clone();

        System.out.println("学生1:   " + stu1.getNumber()+" 学生1地址："+stu1.getAddress().getAdd());
        System.out.println("克隆学生: " + stu2.getNumber()+" 学生2地址："+stu1.getAddress().getAdd());

        stu2.setNumber(2);
        address.setAdd("三河");

        System.out.println("学生1:   " + stu1.getNumber()+" 学生1地址："+stu1.getAddress().getAdd());
        System.out.println("克隆学生: " + stu2.getNumber()+" 学生2地址："+stu2.getAddress().getAdd());
    }
}

自己理解的解释：
错误的浅克隆：

正确的浅克隆：

错误的深克隆

正确的深克隆