被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。
被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象
所引用的对象都复制了一遍。
object类当中提供了浅复制的具体方法
由doc我们可以得出以下几点主要事项
public class CloneTest1
{
public static void main(String[] args) throws Throwable
{
Student student = new Student();
student.setAge(20);
student.setName("zhangsan");
Student student2 = (Student)student.clone();
System.out.println(student2.getAge());
System.out.println(student2.getName());
System.out.println("----------------------");
student2.setName("lisi");
System.out.println(student.getName());
System.out.println(student2.getName());
}
}
class Student implements Cloneable
{
private int age;
private String name;
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
@Override
public Object clone() throws CloneNotSupportedException
{
Object object = super.clone();
return object;
}
深复制我们可以采用浅复制包装,和序列化的方式
public class CloneTest2
{
public static void main(String[] args) throws Exception
{
Teacher teacher = new Teacher();
teacher.setAge(40);
teacher.setName("Teacher zhang");
Student2 s1 = new Student2();
s1.setAge(20);
s1.setName("zhangsan");
s1.setTeacher(teacher);
Student2 s2 = (Student2)s1.clone();
System.out.println(s2.getName());
System.out.println(s2.getAge());
/*
当使用object类的浅复制 此时引用类型不会被复制 他依然指向当前teacher类
会改变clone的成员引用数据
*/
teacher.setName("Teacher Li");
System.out.println(s2.getTeacher().getName());
System.out.println(s2.getTeacher().getAge());
}
}
class Teacher implements Cloneable
{
private int age;
private String name;
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
@Override
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}
class Student2 implements Cloneable
{
private int age;
private String name;
private Teacher teacher;
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Teacher getTeacher()
{
return teacher;
}
public void setTeacher(Teacher teacher)
{
this.teacher = teacher;
}
@Override
public Object clone() throws CloneNotSupportedException
{
Student2 student2 = (Student2)super.clone();
//此时将引用也clone时就会重新生成一个teacher对象
// student2.setTeacher((Teacher)student2.getTeacher().clone());
return student2;
}
}
package com.shengsiyuan.javase.clone;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class CloneTest3
{
public static void main(String[] args) throws Exception
{
Teacher3 t = new Teacher3();
t.setAge(40);
t.setName("Teacher Zhang");
Student3 s1 = new Student3();
s1.setAge(20);
s1.setName("zhangsan");
s1.setTeacher(t);
Student3 s2 = (Student3)s1.deepCopy();
System.out.println(s2.getAge());
System.out.println(s2.getName());
System.out.println("-----------------------");
System.out.println(s2.getTeacher().getAge());
System.out.println(s2.getTeacher().getName());
s2.getTeacher().setAge(50);
s2.getTeacher().setName("Teacher Li");
System.out.println(s1.getTeacher().getAge());
System.out.println(s1.getTeacher().getName());
}
}
class Teacher3 implements Serializable
{
private int age;
private String name;
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
class Student3 implements Serializable
{
private int age;
private String name;
private Teacher3 teacher;
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public Teacher3 getTeacher()
{
return teacher;
}
public void setTeacher(Teacher3 teacher)
{
this.teacher = teacher;
}
public Object deepCopy() throws Exception //此时使用序列化深复制不用考虑引用 引用会随着字节流的写入 被写到JVM当中
{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
我们在使用Object.clone()复制时 如果只是单纯的复制当前类对象 可以使用自带的clone ,如果复制类带有引用类型就需要采用深复制,深复制分为两种 采用序列化方式深复制时和包装重新clone对应的方法来说更加方便我们只需写入读取打印即可无需关心引用类型数据jvm会帮我们自动clone,而重写则需要自己针对不同的引用去复制。
因篇幅问题不能全部显示,请点此查看更多更全内容
Copyright © 2019- niushuan.com 版权所有 赣ICP备2024042780号-2
违法及侵权请联系:TEL:199 1889 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务