java(30) - 对象浅克隆和深克隆

一.浅克隆和深克隆的概念:

       1).浅克隆:又称为浅复制,被复制的对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换而言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。

2).深克隆:又称为深复制,被复制的对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换而言之,深复制就是把要复制的对象所引用的对象都复制了一遍。

二.浅克隆实现:

<pre class="java" name="code"><strong><span style="font-size:18px;">public class Main {

	public static void main(String[] args) throws Exception {
		Student student1 = new Student();
        student1.setName("张三");
        student1.setSex("男");
        student1.setNumber(10);

		Student student2 = (Student)student1.clone();

		System.out.println(student2.getName() +" "+ student2.getNumber() +" "+ student2.getSex());

		student1.setName("李四");
		System.out.println(student1.getName());
		System.out.println(student2.getName());
		System.out.println(student1 == student2);
		System.out.println(student1.getClass() == student2.getClass());
	}
}

class Student implements Cloneable{
	int number;
	String name;
	String sex;

	public int getNumber() {
		return number;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();
		return obj;
	}
}</span></strong>

打印:

张三 10 男

李四

张三

false

true

Object的clone方法就是浅克隆,clone()方法满足(1).对任何对象obj,都有obj.clone()!=obj,克隆的对象与原对象不是一个对象。

三.深克隆实现(这种方式较为麻烦,一般用序列化实现):

public class Main {

	public static void main(String[] args) throws Exception {

		Teacher teacher = new Teacher();
		teacher.setName("李四");
		teacher.setNumber(20);

		Student stu = new Student();
		stu.setName("张三");
		stu.setNumber(10);
		stu.setSex("男");
		stu.setTeacher(teacher);

		Student stu2 = (Student)stu.clone();

		System.out.println(stu2.getTeacher().getName());

		teacher.setName("王五");
		//如果是浅克隆则打印王五,因为teacher引用没变,变得时候teacher中的name属性
		System.out.println(stu2.getTeacher().getName());

	}
}
class Teacher implements Cloneable{
	int number;
	String name;
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {

		return super.clone();
	}
}
class Student implements Cloneable{
	int number;
	String name;
	String sex;
    Teacher  teacher;

	public Teacher getTeacher() {
		return teacher;
	}

	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}

	public int getNumber() {
		return number;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {

		Student student = (Student)super.clone();

		student.setTeacher((Teacher)student.getTeacher().clone());
		return student;
	}
}

打印:

李四

李四



时间: 2024-10-20 12:41:43

java(30) - 对象浅克隆和深克隆的相关文章

浅谈Java中的浅克隆与深克隆

在程序开发中如果已经存在一个对象A,现在需要一个与A对象完全相同的对象B,并对B对象的属性值进行修改,但是A对象原有的属性值不能改变.这是,如果使用Java提供的对象赋值语句,修改B对象的属性值后,A对象的属性值也将被修改.那么此时就应该想到要用java的clone方法去实现. 此时会遇到两种情况:第一种情况是,该对象中所有属性都是基本类型没有引用类型,这时就可以只重写Cloneable接口的clone方法即可:第二种情况就是,该对象中有其他对象的引用类型,此时只是前克隆就会失效,比如下述代码:

java基础入门-对象的浅克隆与深克隆

这里面涉及到两个类,一个是person类,一个是测试类test 首先我们说到的是浅克隆,对某个对象实施Clone时对其是一无所知的,它仅仅是简单地执行域对域的copy,如果是基本数据类型(int,float,char等)到没什么问题,基本遇上如string,Integer等不可变对象的时候也没有什么问题,但是如果遇上了date这个可变对象,或者是自己定义的可变对象,他只是简单的复制一下引用这些可变对象,而不是把这些可变对象再一次的复制 先上person类,这里面虽然是实现Cloneable接口,

Java中的浅克隆(shallow clone)与深克隆(deep clone)

Summary 浅克隆与深克隆对于JavaSE来说,是个难度系数比较低的概念,但不应该轻视它. 假设一个场景:对于某个list,代码里并没有任何对其的直接操作,但里面的元素的属性却被改变了,这可能就涉及到这个概念. Description 浅克隆指仅copy对象位于栈内存中的引用(reference).copy后,新旧两个引用指向同一个堆内存对象(即同一内存区域),但是堆内存中实际的对象copy前后均只有一个.使用"==" operator比较二者的地址会返回true.(不同引用,同一

Java浅克隆和深克隆

什么是浅克隆和深克隆? 克隆顾名思义就是,参照一个东西再做一个出来 浅克隆:直接复写Object的clone()方法,默认情况下8种基本数据类型和String都会进行深克隆,另外的其他引用类型为浅克隆(浅克隆:引用指向的是同一个对象) 深克隆:浅克隆中那另外的其他引用类型都让其变为深克隆 引用类型图解 浅克隆 public class Main { public static void main(String[] args) throws Exception { A a = new A(); A

Java Class对象

Java Class对象 @author ixenos 关键字:RTTI.动态绑定.动态加载.获得Class引用.泛型Class引用.newInstance的坑 RTTI和动态绑定 RTTI即运行时类型识别 Run-Time Type Identification 或 Run-Time Type Information 例如,当把Shape对象放入List<Shape>的数组时会向上转型,但在向上转型为Shape的时候也会丢失Shape对象的具体类型,对于数组而言,他们只是Shape对象.从L

Java Object 对象创建的方式 [ 转载 ]

Java Object 对象创建的方式 [ 转载 ] @author http://blog.csdn.net/mhmyqn/article/details/7943411 显式创建 有4种显式地创建对象的方式: 1.构造器:用new语句创建对象,这是最常用的创建对象的方式. 2.反射:运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法. 3.克隆:调用对象的clone()方法. 4.序列化:运用反

Java Object 对象序列化和反序列化

Java Object 对象序列化和反序列化 @author ixenos 对象序列化是什么 1.对象序列化就是把一个对象的状态转化成一个字节流. 我们可以把这样的字节流存储为一个文件,作为对这个对象的复制(深拷贝):在一些分布式应用中,我们还可以把对象的字节流发送到网络上的其他计算机. 反序列化是把流结构的对象恢复为其原有形式 2.Java平台允许我们在内存中创建可复用的Java对象,但一般情况下,只有当JVM处于运行时,这些对象才可能存在,即,这些对象的生命周期不会比JVM的生命周期更长.但

Java多态对象的类型转换和动态绑定

Java多态对象的类型转换这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候为

[C#]浅克隆和深克隆的区别和在C#中的体现形式

前言:我们知道对象分引用类型和值类型. 浅克隆:复制一个现有对象,引用类型指向同一个内存块(string为最特殊的对象,这里当作值类型来看先) public class User { public int Age { get; set; } public string UserName { get; set; } public List<string> List { get; set; } public User ShallowCopy() { return this.MemberwiseCl