Cloneable接口的作用与深入理解深度克隆与浅度克隆

本文详细介绍了Java中的Cloneable接口及其实现原理,并通过实例对比浅克隆与深克隆的区别,展示了如何实现深度克隆。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

cloneable接口的作用

cloneable其实就是一个标记接口,只有实现这个接口后,然后在类中重写Object中的clone方法,然后通过类调用clone方法才能克隆成功,如果不实现这个接口,则会抛出CloneNotSupportedException(克隆不被支持)异常。Object中clone方法:

这里有一个疑问,Object中的clone方法是一个空的方法,那么他是如何判断类是否实现了cloneable接口呢?

原因在于这个方法中有一个native关键字修饰。

   native修饰的方法都是空的方法,但是这些方法都是有实现体的这里也就间接说明了native关键字不能与abstract同时使用。因为abstract修饰的方法与java的接口中的方法类似,他显式的说明了修饰的方法,在当前是没有实现体的,abstract的方法的实现体都由子类重写,只不过native方法调用的实现体,都是非java代码编写的(例如:调用的是在jvm中编写的C的接口),每一个native方法在jvm中都有一个同名的实现体,native方法在逻辑上的判断都是由实现体实现的,另外这种native修饰的方法对返回类型,异常控制等都没有约束。 

   由此可见,这里判断是否实现cloneable接口,是在调用jvm中的实现体时进行判断的。

深入理解深度克隆与浅度克隆

首先,在java中创建对象的方式有四种:

        一种是new,通过new关键字在堆中为对象开辟空间,在执行new时,首先会看所要创建的对象的类型,知道了类型,才能知道需 要给这个对象分配多大的内存区域,分配内存后,调用对象的构造函数,填充对象中各个变量的值,将对象初始化,然后通过构造方法返回对象的地址;

      另一种是clone,clone也是首先分配内存,这里分配的内存与调用clone方法对象的内存相同,然后将源对象中各个变量的值,填充到新的对象中,填充完成后,clone方法返回一个新的地址,这个新地址的对象与源对象相同,只是地址不同。

另外还有输入输出流,反射构造对象等

下面通过几个例子来解析下浅度克隆与深度克隆的区别:

浅度克隆测试:

首先定义一个学生类

 

public class Student{
	private String name;   //姓名
	private int age;       //年龄
	private StringBuffer sex;  //性别
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public StringBuffer getSex() {
		return sex;
	}
	public void setSex(StringBuffer sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
		
}

其次定义一个学校类,类中重写clone方法

public  class School implements Cloneable{
	private String schoolName;   //学校名称
	private int stuNums;         //学校人数
	private Student stu;         //一个学生
	public String getSchoolName() {
		return schoolName;
	}
	public void setSchoolName(String schoolName) {
		this.schoolName = schoolName;
	}
	public int getStuNums() {
		return stuNums;
	}
	public void setStuNums(int stuNums) {
		this.stuNums = stuNums;
	}
	public Student getStu() {
		return stu;
	}
	public void setStu(Student stu) {
		this.stu = stu;
	}
	@Override
	protected School clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return (School)super.clone();;
	}
	@Override
	public String toString() {
		return "School [schoolName=" + schoolName + ", stuNums=" + stuNums + ", stu=" + stu + "]";
	}
	
}

最后定义一个main类来测试一下:

public static void main(String[] args) throws CloneNotSupportedException {
	School s1 = new School();       
	s1.setSchoolName("实验小学");
	s1.setStuNums(100);
	Student stu1 = new Student();
	stu1.setAge(20);
	stu1.setName("zhangsan");
	stu1.setSex(new StringBuffer("男"));
	s1.setStu(stu1);
	System.out.println("s1: "+s1+" s1的hashcode:"+s1.hashCode()+"  s1中stu1的hashcode:"+s1.getStu().hashCode());
	School s2 = s1.clone();  //调用重写的clone方法,clone出一个新的school---s2
	System.out.println("s2: "+s2+" s2的hashcode:"+s2.hashCode()+" s2中stu1的hashcode:"+s2.getStu().hashCode());
}

测试结果:

     可以看出s1与s2的hashcode不同,也就是说clone方法并不是把s1的引用赋予s2,而是在堆中重新开辟了一块空间,将s1复制过去,将新的地址返回给s2。   

      但是s1中stu的hashcode与s2中stu的hashcode相同,也就是这两个指向了同一个对象,修改s2中的stu会造成s1中stu数据的改变。但是修改s2中的基本数据类型与Stirng类型时,不会造成s1中数据的改变,基本数据类型例如int,在clone的时候会重新开辟一个四个字节的大小的空间,将其赋值。而String则由于String变量的唯一性,如果在s2中改变了String类型的值,则会生成一个新的String对象,对之前的没有影响。  这就是浅度克隆。

如何实现深度clone?(下面时第一种方法,另外使用序列化将student变成流,输入再输出也可以)

首先需要让student重写clone方法,实现cloneable接口

public class Student implements Cloneable{
	
	private String name;
	private int age;
	private StringBuffer sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public StringBuffer getSex() {
		return sex;
	}
	public void setSex(StringBuffer sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	@Override
	protected Student clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return (Student)super.clone();
	}
}

然后,在school的clone方法中将school中的stu对象手动clone一下。

	@Override
	protected School clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		School s = null;
		s = (School)super.clone();
		s.stu = stu.clone();
		return s;
	}

再次执行main方法查看结果:

public class Main {
public static void main(String[] args) throws CloneNotSupportedException {
	School s1 = new School();       
	s1.setSchoolName("实验小学");
	s1.setStuNums(100);
	Student stu1 = new Student();
	stu1.setAge(20);
	stu1.setName("zhangsan");
	stu1.setSex(new StringBuffer("男"));
	s1.setStu(stu1);
	System.out.println("s1: "+s1+" s1的hashcode:"+s1.hashCode()+"  s1中stu1的hashcode:"+s1.getStu().hashCode());
	School s2 = s1.clone();  //调用重写的clone方法,clone出一个新的school---s2
	System.out.println("s2: "+s2+" s2的hashcode:"+s2.hashCode()+" s2中stu1的hashcode:"+s2.getStu().hashCode());
	
	//修改s2中的值,看看是否会对s1中的值造成影响
		 s2.setSchoolName("希望小学");
		 s2.setStuNums(200);
		 Student stu2 = s2.getStu();
		 stu2.setAge(30);
		 stu2.setName("lisi");
		 stu2.setSex(stu2.getSex().append("6666666"));
		 s2.setStu(stu2);
		 
		 //再次打印两个school,查看结果
		 System.out.println("-------------------------------------------------------------------------");
		 System.out.println("s1: "+s1+" hashcode:"+s1.hashCode()+"  s1中stu1的hashcode:"+s1.getStu().hashCode());
		 System.out.println("s2: "+s2+" hashcode:"+s2.hashCode()+" s2中stu1的hashcode:"+s2.getStu().hashCode());
}
}

打印结果:

这里可以看到两个stu的hashcode已经不同了,说明这已经是两个对象了,但是在s2中修改sex的值,为什么还会影响到s1呢?

  原因在于sex的类型是Stringbuffer,在clone的时候将StringBuffer对象的地址传递了过去,而StringBuffer类型没有实现cloneable接口,也没有重写clone方法。

这种情况应该怎么解决呢?

1.只实现浅度clone

2.stu2.setSex(new StringBuffer("newString"));  在设置stu2的sex时创建一个新的StringBuffer对象。
 

### 关于 `Cloneable` 接口的使用和实现细节 在 Java 中,`Cloneable` 是一个标记接口,用于指示对象可以通过其 `clone()` 方法创建副本。如果某个类实现了 `Cloneable` 接口,则表示该类的对象支持克隆操作。然而,仅仅声明实现此接口并不足以完成对象的复制;还需要重写来自 `Object` 类中的默认 `clone()` 方法。 #### 1. **基本概念** 当一个类实现了 `Cloneable` 接口时,它表明这个类希望允许通过调用 `clone()` 来生成它的拷贝实例。如果没有实现 `Cloneable` 而直接调用了 `clone()` 方法,会抛出 `CloneNotSupportedException` 异常[^1]。 #### 2. **实现方式** 为了正确地实现深拷贝或者自定义行为,在子类中通常需要覆盖父类(即 Object 的)方法并提供具体的逻辑: ```java public class MyClass implements Cloneable { private int value; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); // 使用父类提供的功能来执行实际的复制过程 } } ``` 上述代码片段展示了如何在一个简单的类里应用 `Cloneable` 和覆写的 `clone()` 函数[^4]。 #### 3. **注意事项** - 实现 `Cloneable` 不意味着自动获得有效的 `clone()` 功能——开发者仍需显式编写合适的 `clone()` 方法。 - 默认情况下,`clone()` 执行的是拷贝(shallow copy),这意味着对于引用类型的成员变量不会被真正复制而是共享同一个内存地址。要达到深层次的数据独立性可能需要手动处理这些字段。 #### 4. **序列化对比** 尽管两者都可以用来保存状态以便后续恢复,但它们之间存在显著差异。例如,Java 序列化机制能够持久化整个对象图到磁盘文件或其他流媒体形式之中,而 `clone()` 主要是针对运行期间临时性的数据结构镜像需求设计出来的工具。 #### 5. **线程安全性和性能考量** 由于涉及到资源分配以及潜在的竞争条件等问题,因此在线程环境中谨慎运用 `clone()` 技术显得尤为重要。另外值得注意的一点是频繁调用可能会带来额外开销从而影响应用程序的整体效率表现[^3]。 ---
评论 18
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值