Object对象之clone方法

其他 2018-07-15 15:04:05 阅读次数: 0

克隆的目的：快速创建一个已有对象的副本。

克隆的步骤：

  1. 创建一个对象
  2. 将原有对象的数据导入到新创建的数据中

1. Object的clone()源代码简介

  1. /**
  2. * Creates and returns a copy of this {@code Object}. The default
  3. * implementation returns a so-called "shallow" copy: It creates a new
  4. * instance of the same class and then copies the field values (including
  5. * object references) from this instance to the new instance. A "deep" copy,
  6. * in contrast, would also recursively clone nested objects. A subclass that
  7. * needs to implement this kind of cloning should call {@code super.clone()}
  8. * to create the new instance and then create deep copies of the nested,
  9. * mutable objects.
  10. *
  11. * @return a copy of this object.
  12. * @throws CloneNotSupportedException
  13. * if this object's class does not implement the {@code
  14. * Cloneable} interface.
  15. */
  16. protected Object clone() throws CloneNotSupportedException {
  17. if (!( this instanceof Cloneable)) {
  18. throw new CloneNotSupportedException( "Class doesn't implement Cloneable");
  19. }
  21. return internalClone((Cloneable) this);
  22. }
  24. /*
  25. * Native helper method for cloning.
  26. */
  27. private native Object internalClone(Cloneable o);

clone方法首先会判对象是否实现了Cloneable接口，若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法，一般来说native方法的执行效率高于非native方法。

当某个类要复写clone方法时，要继承Cloneable接口。通常的克隆对象都是通过super.clone()方法来克隆对象。


2.浅克隆(shadow clone)

   克隆就是复制一个对象的复本.若只需要复制对象的字段值（对于基本数据类型,如:int,long,float等，则复制值；对于复合数据类型仅复制该字段值，如数组变量则复制地址，对于对象变量则复制对象的reference。

扫描二维码关注公众号，回复： 2161936 查看本文章

例子：

  1. public class ShadowClone implements Cloneable{
  3. private int a; // 基本类型
  4. private int[] b; // 非基本类型
  5. // 重写Object.clone()方法,并把protected改为public
  6. @Override
  7. public Object clone(){
  8. ShadowClone sc = null;
  9. try
  10. {
  11. sc = (ShadowClone) super.clone();
  12. } catch (CloneNotSupportedException e){
  13. e.printStackTrace();
  14. }
  15. return sc;
  16. }
  17. public int getA()
  18. {
  19. return a;
  20. }
  21. public void setA(int a)
  22. {
  23. this.a = a;
  24. }
  25. public int[] getB() {
  26. return b;
  27. }
  28. public void setB(int[] b) {
  29. this.b = b;
  30. }
  31. }
然后进行测试：

  1. public class Test{
  2. public static void main(String[] args) throws CloneNotSupportedException{
  3. ShadowClone c1 = new ShadowClone();
  4. //对c1赋值
  5. c1.setA( 100) ;
  6. c1.setB( new int[]{ 1000}) ;
  8. System.out.println( "克隆前c1: a="+c1.getA()+ " b="+c1.getB()[ 0]);
  9. //克隆出对象c2,并对c2的属性A,B,C进行修改
  10. ShadowClone c2 = (ShadowClone) c1.clone();
  11. //对c2进行修改
  12. c2.setA( 50) ;
  13. int []a = c2.getB() ;
  14. a[ 0]= 5 ;
  15. c2.setB(a);
  16. System.out.println( "克隆前c1: a="+c1.getA()+ " b="+c1.getB()[ 0]);
  17. System.out.println( "克隆后c2: a="+c2.getA()+ " b[0]="+c2.getB()[ 0]);
  18. }
  19. }
结果为：

克隆前c1:  a=100 b=1000
克隆前c1:  a=100 b=5
克隆后c2:  a=50 b[0]=5


c1和c2的对象模型：

                                                                     

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变c2实例对象中的属性就会影响到c1。所以引用类型需要使用深克隆。另外，在开发一个不可变类的时候，如果这个不可变类中成员有引用类型，则就需要通过深克隆来达到不可变的目的。

3.深克隆(deep clone)

    深克隆与浅克隆的区别在于对复合数据类型的复制。若对象中的某个字段为复合类型，在克隆对象的时候，需要为该字段重新创建一个对象。

例子：

  1. public class DeepClone implements Cloneable {
  3. private int a; // 基本类型
  4. private int[] b; // 非基本类型
  5. // 重写Object.clone()方法,并把protected改为public
  6. @Override
  7. public Object clone(){
  8. DeepClone sc = null;
  9. try
  10. {
  11. sc = (DeepClone) super.clone();
  12. int[] t = sc.getB();
  13. int[] b1 = new int[t.length];
  14. for ( int i = 0; i < b1.length; i++) {
  15. b1[i] = t[i];
  16. }
  17. sc.setB(b1);
  18. } catch (CloneNotSupportedException e){
  19. e.printStackTrace();
  20. }
  21. return sc;
  22. }
  23. public int getA()
  24. {
  25. return a;
  26. }
  27. public void setA(int a)
  28. {
  29. this.a = a;
  30. }
  31. public int[] getB() {
  32. return b;
  33. }
  34. public void setB(int[] b) {
  35. this.b = b;
  36. }
  37. }

结果为：

克隆前c1:  a=100 b=1000

克隆前c1:  a=100 b=1000
克隆后c2:  a=50 b[0]=5

对象模型：

                                        


4、总结：

  1. 克隆方法用于创建对象的拷贝，为了使用clone方法，类必须实现java.lang.Cloneable接口重写protected方法clone，如果没有实现Clonebale接口会抛出CloneNotSupportedException.
  2. 在克隆java对象的时候不会调用构造器
  3. java提供一种叫浅拷贝（shallow copy）的默认方式实现clone，创建好对象的副本后然后通过赋值拷贝内容，意味着如果你的类包含引用类型，那么原始对象和克隆都将指向相同的引用内容，这是很危险的，因为发生在可变的字段上任何改变将反应到他们所引用的共同内容上。为了避免这种情况，需要对引用的内容进行深度克隆。



克隆的目的：快速创建一个已有对象的副本。

克隆的步骤：

  1. 创建一个对象
  2. 将原有对象的数据导入到新创建的数据中

1. Object的clone()源代码简介

  1. /**
  2. * Creates and returns a copy of this {@code Object}. The default
  3. * implementation returns a so-called "shallow" copy: It creates a new
  4. * instance of the same class and then copies the field values (including
  5. * object references) from this instance to the new instance. A "deep" copy,
  6. * in contrast, would also recursively clone nested objects. A subclass that
  7. * needs to implement this kind of cloning should call {@code super.clone()}
  8. * to create the new instance and then create deep copies of the nested,
  9. * mutable objects.
  10. *
  11. * @return a copy of this object.
  12. * @throws CloneNotSupportedException
  13. * if this object's class does not implement the {@code
  14. * Cloneable} interface.
  15. */
  16. protected Object clone() throws CloneNotSupportedException {
  17. if (!( this instanceof Cloneable)) {
  18. throw new CloneNotSupportedException( "Class doesn't implement Cloneable");
  19. }
  21. return internalClone((Cloneable) this);
  22. }
  24. /*
  25. * Native helper method for cloning.
  26. */
  27. private native Object internalClone(Cloneable o);

clone方法首先会判对象是否实现了Cloneable接口，若无则抛出CloneNotSupportedException, 最后会调用internalClone. intervalClone是一个native方法，一般来说native方法的执行效率高于非native方法。

当某个类要复写clone方法时，要继承Cloneable接口。通常的克隆对象都是通过super.clone()方法来克隆对象。


2.浅克隆(shadow clone)

   克隆就是复制一个对象的复本.若只需要复制对象的字段值（对于基本数据类型,如:int,long,float等，则复制值；对于复合数据类型仅复制该字段值，如数组变量则复制地址，对于对象变量则复制对象的reference。

例子：

  1. public class ShadowClone implements Cloneable{
  3. private int a; // 基本类型
  4. private int[] b; // 非基本类型
  5. // 重写Object.clone()方法,并把protected改为public
  6. @Override
  7. public Object clone(){
  8. ShadowClone sc = null;
  9. try
  10. {
  11. sc = (ShadowClone) super.clone();
  12. } catch (CloneNotSupportedException e){
  13. e.printStackTrace();
  14. }
  15. return sc;
  16. }
  17. public int getA()
  18. {
  19. return a;
  20. }
  21. public void setA(int a)
  22. {
  23. this.a = a;
  24. }
  25. public int[] getB() {
  26. return b;
  27. }
  28. public void setB(int[] b) {
  29. this.b = b;
  30. }
  31. }
然后进行测试：

  1. public class Test{
  2. public static void main(String[] args) throws CloneNotSupportedException{
  3. ShadowClone c1 = new ShadowClone();
  4. //对c1赋值
  5. c1.setA( 100) ;
  6. c1.setB( new int[]{ 1000}) ;
  8. System.out.println( "克隆前c1: a="+c1.getA()+ " b="+c1.getB()[ 0]);
  9. //克隆出对象c2,并对c2的属性A,B,C进行修改
  10. ShadowClone c2 = (ShadowClone) c1.clone();
  11. //对c2进行修改
  12. c2.setA( 50) ;
  13. int []a = c2.getB() ;
  14. a[ 0]= 5 ;
  15. c2.setB(a);
  16. System.out.println( "克隆前c1: a="+c1.getA()+ " b="+c1.getB()[ 0]);
  17. System.out.println( "克隆后c2: a="+c2.getA()+ " b[0]="+c2.getB()[ 0]);
  18. }
  19. }
结果为：

克隆前c1:  a=100 b=1000
克隆前c1:  a=100 b=5
克隆后c2:  a=50 b[0]=5


c1和c2的对象模型：

                                                                     

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变c2实例对象中的属性就会影响到c1。所以引用类型需要使用深克隆。另外，在开发一个不可变类的时候，如果这个不可变类中成员有引用类型，则就需要通过深克隆来达到不可变的目的。

3.深克隆(deep clone)

    深克隆与浅克隆的区别在于对复合数据类型的复制。若对象中的某个字段为复合类型，在克隆对象的时候，需要为该字段重新创建一个对象。

例子：

  1. public class DeepClone implements Cloneable {
  3. private int a; // 基本类型
  4. private int[] b; // 非基本类型
  5. // 重写Object.clone()方法,并把protected改为public
  6. @Override
  7. public Object clone(){
  8. DeepClone sc = null;
  9. try
  10. {
  11. sc = (DeepClone) super.clone();
  12. int[] t = sc.getB();
  13. int[] b1 = new int[t.length];
  14. for ( int i = 0; i < b1.length; i++) {
  15. b1[i] = t[i];
  16. }
  17. sc.setB(b1);
  18. } catch (CloneNotSupportedException e){
  19. e.printStackTrace();
  20. }
  21. return sc;
  22. }
  23. public int getA()
  24. {
  25. return a;
  26. }
  27. public void setA(int a)
  28. {
  29. this.a = a;
  30. }
  31. public int[] getB() {
  32. return b;
  33. }
  34. public void setB(int[] b) {
  35. this.b = b;
  36. }
  37. }

结果为：

克隆前c1:  a=100 b=1000

克隆前c1:  a=100 b=1000
克隆后c2:  a=50 b[0]=5

对象模型：

                                        


4、总结：

  1. 克隆方法用于创建对象的拷贝，为了使用clone方法，类必须实现java.lang.Cloneable接口重写protected方法clone，如果没有实现Clonebale接口会抛出CloneNotSupportedException.
  2. 在克隆java对象的时候不会调用构造器
  3. java提供一种叫浅拷贝（shallow copy）的默认方式实现clone，创建好对象的副本后然后通过赋值拷贝内容，意味着如果你的类包含引用类型，那么原始对象和克隆都将指向相同的引用内容，这是很危险的，因为发生在可变的字段上任何改变将反应到他们所引用的共同内容上。为了避免这种情况，需要对引用的内容进行深度克隆。



猜你喜欢

转载自blog.csdn.net/sunmeok/article/details/80995808
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022