浅克隆和深克隆及序列化

最新推荐文章于 2021-12-10 20:48:56 发布

whp0731

最新推荐文章于 2021-12-10 20:48:56 发布

阅读量119

点赞数

分类专栏： J2SE 文章标签： Eclipse JVM

J2SE 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、相关概念：

1、浅复制与深复制概念
浅复制（浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
2、浅复制与深复制概念
深复制（深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
3、Java的clone()方法【定义在Object类中】
clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x
克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()
克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
4、Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。
5、①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？
在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone()方法是浅复制

程序代码：

1）、一般克隆（浅克隆）

package com.clone;

public class CloneTest1
{

	public static void main(String[] args)throws CloneNotSupportedException
	{
		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;
	}
	
	
}

2）、深克隆

package com.clone;

public class CloneTest2
{

	public static void main(String[] args) throws CloneNotSupportedException
	{
		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.getAge());
		System.out.println(s2.getName());

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");

		System.out.println(s2.getTeacher().getAge());
		System.out.println(s2.getTeacher().getName());

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");

		s2.getTeacher().setAge(50);
		s2.getTeacher().setName("Teacher Li");

		System.out.println(s1.getTeacher().getAge());
		System.out.println(s1.getTeacher().getName());

	}

}

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();

		student2.setTeacher((Teacher) student2.getTeacher().clone());

		return student2;

	}

}

6、把对象写到流里的过程是序列化（Serilization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。
7、在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。
8、注意：Cloneable与Serializable都是marker Interface,也就是说他们只是一个标识接口，没有定义任何方法。
9、当一个类实现了Serializable接口时，表明该类可被序列化，这个时候Eclipse会要求你为该类定义一个字段，该字段名字为serialVersionUID，类型为long，提示信息如下
10、The serializable class Student4 does not declare a static final serialVersionUID field of type long
11、你可以随便写一个，在Eclipse中它替你生成一个，有两种生成方式：一个是默认的1L，比如：private static final long serialVersionUID = 1L;一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = 8940196742313994740L;之类的。
12、当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义之。在Eclipse中点击类中warning的图标一下【即那个黄色的图标】，Eclipse就会自动给定两种生成的方式，如上面所述。如果不想定义它，在Eclipse的设置中也可以把它关掉的，设置如下
Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems 将Serializable class without serialVersionUID的warning改成ignore即可。
13、如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别Serializable向后兼容。
14、如果你的对象序列化后存到硬盘上面后，可是后来你却更改了类的field(增加或减少或改名)，当你反序列化时，就会出现Exception的，这样就会造成不兼容性的问题。
但当serialVersionUID相同时，它就会将不一样的field以type的缺省值Deserialize，这个可以避开不兼容性的问题。

3）序列化克隆程序

package com.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("~~~~~~~~~~~~~~~~~~~");

		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
{//默认就是深度拷贝，会把所引用的对象也序列化了，即级联的概念，同时保存他们的关系，到时反序列化时全套还原
		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();

	}
}