当前位置: 首页 > 编程笔记 >

深入理解Java中的克隆

阎经武
2023-03-14
本文向大家介绍深入理解Java中的克隆,包括了深入理解Java中的克隆的使用技巧和注意事项,需要的朋友参考一下

前言

Java克隆(Clone)是Java语言的特性之一,但在实际中应用比较少见。但有时候用克隆会更方便更有效率。

对于克隆(Clone),Java有一些限制:

      1、被克隆的类必须自己实现Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口,没有任何接口方法。

      2、实现Cloneable接口的类应该使用公共方法重写 Object.clone(它是受保护的)。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的,也无法保证它将获得成功。

      3、在Java.lang.Object类中克隆方法是这么定义的:

        protected Object clone()
        throws CloneNotSupportedException

创建并返回此对象的一个副本。表明是一个受保护的方法,同一个包中可见。

按照惯例,返回的对象应该通过调用 super.clone 获得。

Java中的赋值

在Java中,赋值是很常用的,一个简单的赋值如下

//原始类型
int a = 1;
int b = a;

//引用类型
String[] weekdays = new String[5];
String[] gongzuori = weekdays;//仅拷贝引用

在上述代码中。

      1、如果是原始数据类型,赋值传递的为真实的值

      2、如果是引用数据类型,赋值传递的为对象的引用,而不是对象。

了解了数据类型和引用类型的这个区别,便于我们了解clone。

Clone

在Java中,clone是将已有对象在内存中复制出另一个与之相同的对象的过程。java中的克隆为逐域复制。

在Java中想要支持clone方法,需要首先实现Cloneable接口

Cloneable其实是有点奇怪的,它不同与我们常用到的接口,它内部不包含任何方法,它仅仅是一个标记接口。

其源码如下

public interface Cloneable {
}

关于cloneable,需要注意的

      1、如果想要支持clone,就需要实现Cloneable 接口

      2、如果没有实现Cloneable接口的调用clone方法,会抛出CloneNotSupportedException异常。

然后是重写clone方法,并修改成public访问级别

static class CloneableImp implements Cloneable {
 public int count;
 public Child child;
   
   
 @Override
 public Object clone() throws CloneNotSupportedException {
   return super.clone();
 }
}

调用clone方法复制对象

CloneableImp imp1 = new CloneableImp();
imp1.child = new Child("Andy");
try {
 Object obj = imp1.clone();
 CloneableImp imp2 = (CloneableImp)obj;
 System.out.println("main imp2.child.name=" + imp2.child.name);
} catch (CloneNotSupportedException e) {
 e.printStackTrace();
}

浅拷贝

上面的代码实现的clone实际上是属于浅拷贝(Shallow Copy)。

关于浅拷贝,你该了解的

     1、使用默认的clone方法

     2、对于原始数据域进行值拷贝

     3、对于引用类型仅拷贝引用

     4、执行快,效率高

     5、不能做到数据的100%分离。

     6、如果一个对象只包含原始数据域或者不可变对象域,推荐使用浅拷贝。

关于无法做到数据分离,我们可以使用这段代码验证

CloneableImp imp1 = new CloneableImp();
imp1.child = new Child("Andy");
try {
 Object obj = imp1.clone();
 CloneableImp imp2 = (CloneableImp)obj;
 imp2.child.name = "Bob";
     
 System.out.println("main imp1.child.name=" + imp1.child.name);
} catch (CloneNotSupportedException e) {
 e.printStackTrace();
}

上述代码我们使用了imp1的clone方法克隆出imp2,然后修改 imp2.child.name 为 Bob,然后打印imp1.child.name 得到的结果是

main imp1.child.name=Bob

原因是浅拷贝并没有做到数据的100%分离,imp1和imp2共享同一个Child对象,所以一个修改会影响到另一个。

深拷贝

深拷贝可以解决数据100%分离的问题。只需要对上面代码进行一些修改即可。

1、Child实现Cloneable接口。

public class Child implements Cloneable{

 public String name;

 public Child(String name) {
   this.name = name;
 }

 @Override
 public String toString() {
   return "Child [name=" + name + "]";
 }

 @Override
 protected Object clone() throws CloneNotSupportedException {
   return super.clone();
 }
}

2.重写clone方法,调用数据域的clone方法。

static class CloneableImp implements Cloneable {
 public int count;
 public Child child;
   
   
 @Override
 public Object clone() throws CloneNotSupportedException {
   CloneableImp obj = (CloneableImp)super.clone();
   obj.child = (Child) child.clone();
   return obj;
 }
}

当我们再次修改imp2.child.name就不会影响到imp1.child.name的值了,因为imp1和imp2各自拥有自己的child对象,因为做到了数据的100%隔离。

关于深拷贝的一些特点

      1、需要重写clone方法,不仅仅只调用父类的方法,还需调用属性的clone方法

      2、做到了原对象与克隆对象之间100%数据分离

      3、如果是对象存在引用类型的属性,建议使用深拷贝

      4、深拷贝比浅拷贝要更加耗时,效率更低

为什么使用克隆

很重要并且常见的常见就是:某个API需要提供一个List集合,但是又不希望调用者的修改影响到自身的变化,因此需要克隆一份对象,以此达到数据隔离的目的。

应尽量避免clone

      1.通常情况下,实现接口是为了表明类可以为它的客户做些什么,而Cloneable仅仅是一个标记接口,而且还改变了超类中的手保护的方法的行为,是接口的一种极端非典型的用法,不值得效仿。

      2.Clone方法约定及其脆弱 clone方法的Javadoc描述有点暧昧模糊,如下为 Java SE8的约定

          clone方法创建并返回该对象的一个拷贝。而拷贝的精确含义取决于该对象的类。一般的含义是,对于任何对象x,表达式

          x.clone() != x 为 true x.clone().getClass() == x.getClass() 也返回true,但非必须 x.clone().equals(x) 也返回true,但也不是必须的

上面的第二个和第三个表达式很容易就返回false。因而唯一能保证永久为true的就是表达式一,即两个对象为独立的对象。

       3.可变对象final域 在克隆方法中,如果我们需要对可变对象的final域也进行拷贝,由于final的限制,所以实际上是无法编译通过的。因此为了实现克隆,我们需要考虑舍去该可变对象域的final关键字。

       4.线程安全 如果你决定用线程安全的类实现Cloneable接口,需要保证它的clone方法做好同步工作。默认的Object.clone方法是没有做同步的。

总的来说,java中的clone方法实际上并不是完善的,建议尽量避免使用。如下是一些替代方案。

Copy constructors

使用复制构造器也可以实现对象的拷贝。

      1、复制构造器也是构造器的一种

      2、只接受一个参数,参数类型为当前的类

      3、目的是生成一个与参数相同的新对象

      4、复制构造器相比clone方法的优势是简单,易于实现。

一段使用了复制构造器的代码示例

public class Car {
 Wheel wheel;
 String manufacturer;
 
 public Car(Wheel wheel, String manufacturer) {
   this.wheel = wheel;
   this.manufacturer = manufacturer;
 }
 
 //copy constructor
 public Car(Car car) {
   this(car.wheel, car.manufacturer);
 }
 
 public static class Wheel {
   String brand;
 }
}

注意,上面的代码实现为浅拷贝,如果想要实现深拷贝,参考如下代码

//copy constructor
public Car(Car car) {
 Wheel wheel = new Wheel();
 wheel.brand = car.wheel.brand;
   
 this.wheel = wheel;
 this.manufacturer = car.manufacturer;
}

为了更加便捷,我们还可以为上述类增加一个静态的方法

public static Car newInstance(Car car) {
 return new Car(car);
}

使用Serializable实现深拷贝

其实,使用序列化也可以实现对象的深拷贝。简略代码如下

public class DeepCopyExample implements Serializable{
 private static final long serialVersionUID = 6098694917984051357L;
 public Child child;
 
 public DeepCopyExample copy() {
   DeepCopyExample copy = null;
   try {
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     ObjectOutputStream oos = new ObjectOutputStream(baos);
     oos.writeObject(this);
 
     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
     ObjectInputStream ois = new ObjectInputStream(bais);
     copy = (DeepCopyExample) ois.readObject();
   } catch (IOException e) {
     e.printStackTrace();
   } catch (ClassNotFoundException e) {
     e.printStackTrace();
   }
   return copy;
 }
}

其中,Child必须实现Serializable接口

public class Child implements Serializable{
 private static final long serialVersionUID = 6832122780722711261L;
 public String name = "";

 public Child(String name) {
   this.name = name;
 }

 @Override
 public String toString() {
   return "Child [name=" + name + "]";
 }
}

使用示例兼测试代码

DeepCopyExample example = new DeepCopyExample();
example.child = new Child("Example");
   
DeepCopyExample copy = example.copy();
if (copy != null) {
 copy.child.name = "Copied";
 System.out.println("example.child=" + example.child + ";copy.child=" + copy.child);
}
//输出结果:example.child=Child [name=Example];copy.child=Child [name=Copied]

由输出结果来看,copy对象的child值修改不影响example对象的child值,即使用序列化可以实现对象的深拷贝。

总结

以上就是Java中克隆的全部内容,希望本文对大家学习Java能有所帮助。

 类似资料:
  • 本文向大家介绍深入了解Java对象的克隆,包括了深入了解Java对象的克隆的使用技巧和注意事项,需要的朋友参考一下   今天要介绍一个概念,对象的克隆。本篇有一定难度,请先做好心理准备。看不懂的话可以多看两遍,还是不懂的话,可以在下方留言,我会看情况进行修改和补充。   克隆,自然就是将对象重新复制一份,那为什么要用克隆呢?什么时候需要使用呢?先来看一个小栗子:   简单起见,我们这里用的是Goo

  • 本文向大家介绍深入理解Java中的接口,包括了深入理解Java中的接口的使用技巧和注意事项,需要的朋友参考一下 一. 为什么要使用接口 假如有一个需求:要求实现防盗门的功能。门有"开"和"关"的功能,锁有"上锁"和"开锁"的功能。 分析:首先防盗门是一个门,门有开门和关门的功能,还有一把锁,锁有开锁和上锁,按照面向对象的编程的思想,我们会将门和锁都作为一个类而单独存在,但是,不能让防盗门继承自门的

  • 本文向大家介绍深入理解java中Arrays.sort()的用法,包括了深入理解java中Arrays.sort()的用法的使用技巧和注意事项,需要的朋友参考一下 Java的Arrays类中有一个sort()方法,该方法是Arrays类的静态方法,在需要对数组进行排序时,非常的好用。 但是sort()的参数有好几种,基本上是大同小异,下面是以int型数组为例的Arrays.sort()的典型用法

  • 本文向大家介绍深入理解Java中的SPI机制,包括了深入理解Java中的SPI机制的使用技巧和注意事项,需要的朋友参考一下 本文通过探析JDK提供的,在开源项目中比较常用的Java SPI机制,希望给大家在实际开发实践、学习开源项目提供参考。 1 SPI是什么 SPI全称Service Provider Interface,是Java提供的一套用来被第三方实现或者扩展的API,它可以用来启用框架扩

  • 本文向大家介绍深入理解Java中的弱引用,包括了深入理解Java中的弱引用的使用技巧和注意事项,需要的朋友参考一下 不久之前,我面试了一些求职Java高级开发工程师的应聘者。我常常会面试他们说,“你能给我介绍一些Java中得弱引用吗?”,如果面试者这样说,“嗯,是不是垃圾回收有关的?”,我就会基本满意了,我并不期待回答是一篇诘究本末的论文描述。 然而事与愿违,我很吃惊的发现,在将近20多个有着平均

  • 本文向大家介绍深入理解java中的null“类型”,包括了深入理解java中的null“类型”的使用技巧和注意事项,需要的朋友参考一下 本文研究的主要是java中的null“类型”的相关实例,具体介绍如下。 先给出一道简单的null相关的题目,引发我们对null的探讨,后面会根据官方语言手册对null“类型”进行解读。 题目:下面程序能正确运行吗? 解析: 输出应该为 :haha 因为null 是