关于java拷贝的笔记

1、直接引用

直接引用对基本数据类型与引用数据类型都不会复制一份新的，使用的都是原来的值

package clone;

public class Reference {
	public static void main(String[] args){
		People3 people=new People3();
		people.num=1315;
		Student3 stu1=new Student3();		
		stu1.age=1;
		stu1.people3=people;
		
		System.out.println("-----------原对象----------------------");
		System.out.println("stu1:"+stu1);
		System.out.println("stu1->age:"+stu1.age);
		System.out.println("stu1->num:"+stu1.people3);
		System.out.println("stu1->pepole3->num:"+stu1.people3.num);
		
		Student3 stu2=(Student3) stu1;
		
		System.out.println("-----------引用出来的对象----------------- ");
		System.out.println("stu2:"+stu2);
		System.out.println("stu2->age:"+stu2.age);
		System.out.println("stu2->num:"+stu2.people3);
		System.out.println("stu2->pepole3->num:"+stu2.people3.num);
		
		stu1.age=3;
		stu1.people3.num=1327;
		System.out.println("-----------修改原对象对引用对象的影响-----------");
		System.out.println("stu2:"+stu2);
		System.out.println("stu2->age:"+stu2.age);
		System.out.println("stu2->num:"+stu2.people3);
		System.out.println("stu2->num:"+stu2.people3.num);	
		}
}
class Student3 implements Cloneable{
	public int age;
	public People3 people3;
}
class People3{
	public int num;
}

输出的结果是这样的：

当改变原对象的基本数据类型与引用数据类型，新对象的基本数据类型与引用数据类型的值都会变，而且可以看到对象的hashcode值都是一样的

2、浅拷贝

浅拷贝会对基本数据类型复制一份新的，对引用数据类型会使用原来的对象的

package clone;

public class ShallowCopy {
	public static void main(String[] args){
		People people=new People();
		people.num=1234;
		Student stu1=new Student();
		stu1.age=1;
		stu1.people=people;
		
		System.out.println("-----------原对象----------------------");
		System.out.println("stu1:"+stu1);
		System.out.println("stu1->age:"+stu1.age);
		System.out.println("stu1->num:"+stu1.people);
		System.out.println("stu1->pepole->num:"+stu1.people.num);
		
		try {
			System.out.println("-----------浅拷贝出的对象--------------");
			Student stu2=(Student) stu1.clone();
			System.out.println("stu2:"+stu2);
			System.out.println("stu2->age:"+stu2.age);
			System.out.println("stu2->num:"+stu2.people);
			System.out.println("stu2->pepole->num:"+stu2.people.num);

			stu1.age=3;
			people.num=2345;
			System.out.println("--------修改原对象对浅拷贝出的对象的影响-----------");
			System.out.println("stu2:"+stu2);
			System.out.println("stu2->age:"+stu2.age);
			System.out.println("stu2->num:"+stu2.people);
			System.out.println("stu2->pepole->num:"+stu2.people.num);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}
class Student implements Cloneable{
	public int age;
	public People people;
		
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class People{
	public int num;
}

输出的结果是这样的：

当改变原对象的基本数据类型与引用数据类型，新对象的基本数据类型不变，引用数据类型的值会变，而且可以看到对象的hashcode值是一样的

3、深拷贝

package clone;

public class DeepCopy {
	public static void main(String[] args){
	People2 people2=new People2();
	people2.num=3456;
	Student2 stu1=new Student2();
	stu1.age=1;
	stu1.people2=people2;
	
	System.out.println("-----------原对象----------------------");
	System.out.println("stu1:"+stu1);
	System.out.println("stu1->age:"+stu1.age);
	System.out.println("stu1->num:"+stu1.people2);
	System.out.println("stu1->pepole->num:"+stu1.people2.num);
	try {
		Student2 stu2=(Student2) stu1.clone();
		System.out.println("-----------深拷贝出的对象--------------");
		System.out.println("stu2:"+stu2);
		System.out.println("stu2->age:"+stu2.age);
		System.out.println("stu2->num:"+stu2.people2);
		System.out.println("stu2->pepole->num:"+stu2.people2.num);
		
		stu1.age=3;
		stu1.people2.num=6789;
		
		System.out.println("--------修改原对象对深拷贝出的对象的影响-----------");
		System.out.println("stu2:"+stu2);
		System.out.println("stu2->age:"+stu2.age);
		System.out.println("stu2->num:"+stu2.people2);
		System.out.println("stu2->pepole->num:"+stu2.people2.num);
	} catch (CloneNotSupportedException e) {
		e.printStackTrace();
	}
	}
}
class Student2 implements Cloneable{
	public int age;
	public People2 people2;
		
    @Override
    public Object clone() throws CloneNotSupportedException {
    	Student2 st2=null;
    	try {
    		st2 = (Student2) super.clone();
            if (people2 != null) {
                st2.people2=(People2)people2.clone();
            }
        } catch (CloneNotSupportedException ignored) {
            
        }
        return st2;
    }
}
class People2 implements Cloneable{
	public int num;
	@Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

输出结果是这样的：

当改变原对象的基本数据类型与引用数据类型，新对象的基本数据类型和引用数据类型的值都不会变，而且可以看到引用对象的hashcode值是不一样的

总结一下，图大概是这样子的：

还有一个问题，包装类型的处理是遵循基本数据类型的。