今天要介绍一个概念,对象的克隆。本篇有一定难度,请先做好心理准备。看不懂的话可以多看两遍,还是不懂的话,可以在下方留言,我会看情况进行修改和补充。

克隆,自然就是将对象重新复制一份,那为什么要用克隆呢?什么时候需要使用呢?先来看一个小栗子:

简单起见,我们这里用的是Goods类的简单版本。

public class Goods {
private String title;
private double price; public Goods(String aTitle, double aPrice){
title = aTitle;
price = aPrice;
} public void setPrice(double price) {
this.price = price;
} public void setTitle(String title) {
this.title = title;
}   //用于打印输出商品信息
public void print(){
System.out.println("Title:"+title+" Price:"+price);
}
}

然后我们来使用这个类。

public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);
Goods goodsB = goodsA;
System.out.println("Before Change:");
goodsA.print();
goodsB.print(); goodsB.setTitle("GoodsB");
goodsB.setPrice(50);
System.out.println("After Change:");
goodsA.print();
goodsB.print();
}
}

我们创建了一个Goods对象赋值给变量goodsA,然后又创建了一个Goods变量,并把goodsA赋值给它,先调用Goods的print方法输出这两个变量中的信息,然后调用Goods类中的setTitle和setPrice方法来修改goodsB中的对象内容,再输出两个变量中的信息,下面是输出:

Before Change:
Title:GoodsA Price:20.0
Title:GoodsA Price:20.0
After Change:
Title:GoodsB Price:50.0
Title:GoodsB Price:50.0

这里我们发现了灵异事,我们明明修改的是goodsB的内容,可是goodsA的内容也同样发生了改变,这究竟是为什么呢?别心急,且听我慢慢道来。

在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类型包括类、接口、数组等复杂类型。使用等号赋值都是进行值传递的,如将一个整数型变量赋值给另一个整数型变量,那么后者将存储前者的值,也就是变量中的整数值,对于基本类型如int,double,char等是没有问题的,但是对于对象,则又是另一回事了,这里的goodsA和goodsB都是Goods类对象的变量,但是它们并没有存储Goods类对象的内容,而是存储了它的地址,也就相当于C++中的指针,如果对于指针不了解,那我就再举个栗子好了。我们之前举过一个栗子,把计算机比作是仓库管理员,内存比作是仓库,你要使用什么类型的变量,就需要先登记,然后管理员才会把东西给你,但如果是给你分配一座房子呢?这时候不是把房子搬起来放到登记簿粒,而是登记下房子的地址,这里的地址就是我们的类对象变量里记录的内容,所以,当我们把一个类对象变量赋值给另一个类对象变量,如goodsB = goodsA时,实际上只是把A指向的对象地址赋值给了B,这样B也同样指向这个地址,所以这时候,goodsA和goodsB操作的是同一个对象。

所以,如果只是简单的赋值的话,之后对于goodsA和goodsB的操作都将影响同一个对象,这显然不是我们的本意。也许你还会问,直接再new一个对象不就好了,确实如此,但有时候,如果我们需要保存一个goodsA的副本,那就不仅仅要new一个对象,还需要进行一系列赋值操作才能将我们的新对象设置成跟goodsA对象一样,而且Goods类越复杂,这个操作将会越繁琐,另外使用clone方法还进行本地优化,效率上也会快很多,总而言之,就是简单粗暴。

那如何使用克隆呢?这里我们就要介绍我们牛逼哄哄的Object类了,所有的类都是Object类的子类,虽然我们并没有显式声明继承关系,但所有类都难逃它的魔掌,它有两个protected方法,其中一个就是clone方法。

下面我来展示一波正确的骚操作:

//要使用克隆方法需要实现Cloneable接口
public class Goods implements Cloneable{
private String title;
private double price; public Goods(String aTitle, double aPrice){
title = aTitle;
price = aPrice;
} public void setPrice(double price) {
this.price = price;
} public void setTitle(String title) {
this.title = title;
} public void print(){
System.out.println("Title:"+title+" Price:"+price);
} //这里重载了接口的clone方法
@Override
protected Object clone(){
Goods g = null;
    //这里是异常处理的语句块,可以先不用了解,只要知道是这样使用就好,之后的文章中会有详细的介绍
try{
g = (Goods)super.clone();
}catch (CloneNotSupportedException e){
System.out.println(e.toString());
}
return g;
}
}

其实修改的地方只有两个,一个是定义类的时候实现了Cloneable接口,关于接口的知识在之后会有详细说明,这里只要简单理解为是一种规范就行了,然后我们重载了clone方法,并在里面调用了父类也就是(Object)的clone方法。可以看到我们并没有new一个新的对象,而是使用父类的clone方法进行克隆,关于try catch的知识这里不做过多介绍,之后会有文章做详细说明,这里只需要理解为try语句块里是一个可能发生错误的代码,catch会捕获这种错误并进行处理。

接下来我们再使用这个类的克隆方法:

public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);
Goods goodsB = (Goods)goodsA.clone();
System.out.println("Before Change:");
goodsA.print();
goodsB.print(); goodsB.setTitle("GoodsB");
goodsB.setPrice(50);
System.out.println("After Change:");
goodsA.print();
goodsB.print();
}
}

我们仅仅是把赋值改成了调用goodsA的clone方法并进行类型转换。输出如下:

Before Change:
Title:GoodsA Price:20.0
Title:GoodsA Price:20.0
After Change:
Title:GoodsA Price:20.0
Title:GoodsB Price:50.0

看,这样不就达到我们目的了吗?是不是很简单?

但是别高兴的太早,关于克隆,还有一点内容需要介绍。

克隆分为浅克隆和深克隆。我们上面使用的只是浅克隆,那两者有什么区别呢?这里再举一个栗子,使用的是简化版的Cart类:

public class Cart implements Cloneable{
//实例域
Goods goodsList = new Goods("",0);//简单起见,这里只放了一个商品
double budget = 0.0;//预算 //构造函数
public Cart(double aBudget){
budget = aBudget;
} //获取预算
public double getBudget() {
return budget;
} //修改预算
public void setBudget(double aBudget) {
budget = aBudget;
} //这里只是简单的将商品进行了赋值
public void addGoods(Goods goods){
goodsList = (Goods) goods.clone();
} //这是为了演示加上的代码,仅仅将商品标题修改成新标题
public void changeGoodsTitle(String title){
goodsList.setTitle(title);
} //打印商品信息
public void print(){
System.out.print("Cart内的预算信息:"+budget+" 商品信息:");
goodsList.print();
} //重载clone方法
@Override
protected Object clone(){
Cart c = null;
try{
c = (Cart)super.clone();
}catch (CloneNotSupportedException e ){
e.printStackTrace();
}
return c;
}
}

这里将goodsList由数组改成了单个对象变量,仅仅用于演示方便,还增加了一个changeGoodsTitle方法,用于将商品的标题修改成另一个标题,接下来修改一下GoodsTest类:

public class GoodsTest {
public static void main(String[] args){
Goods goodsA = new Goods("GoodsA",20);//新建一个商品对象
Cart cartA = new Cart(5000);//新建一个购物车对象
cartA.addGoods(goodsA);//添加商品
Cart cartB = (Cart) cartA.clone();//使用浅克隆      //输出修改前信息
System.out.println("Before Change:");
cartA.print();
cartB.print();      //修改购物车A中的商品标题
cartA.changeGoodsTitle("NewTitle");
     //重新输出修改后的信息
System.out.println("After Change:");
cartA.print();
cartB.print();
}
}

输出信息:

Before Change:
Cart内的预算信息:5000.0 商品信息:Title:GoodsA Price:20.0
Cart内的预算信息:5000.0 商品信息:Title:GoodsA Price:20.0
After Change:
Cart内的预算信息:5000.0 商品信息:Title:NewTitle Price:20.0
Cart内的预算信息:5000.0 商品信息:Title:NewTitle Price:20.0

我们发现,虽然我们调用的是cartA中的方法修改购物车A中的商品信息,但购物车B中的信息同样被修改了,这是因为使用浅克隆模式的时候,成员变量如果是对象等复杂类型时,仅仅使用的是值拷贝,就跟我们之前介绍的那样,所以cartB虽然是cartA的一个拷贝,但是它们的成员变量goodsList却共用一个对象,这样就藕断丝连了,显然不是我们想要的效果,这时候就需要使用深拷贝了,只需要将Cart类的clone方法修改一下即可:

   @Override
protected Object clone(){
Cart c = null;
try{
c = (Cart)super.clone();
c.goodsList = (Goods) goodsList.clone();//仅仅添加了这段代码,将商品对象也进行了克隆
}catch (CloneNotSupportedException e ){
e.printStackTrace();
}
return c;
}

现在再来运行一下:

Before Change:
Cart内的预算信息:5000.0 商品信息:Title:GoodsA Price:20.0
Cart内的预算信息:5000.0 商品信息:Title:GoodsA Price:20.0
After Change:
Cart内的预算信息:5000.0 商品信息:Title:NewTitle Price:20.0
Cart内的预算信息:5000.0 商品信息:Title:GoodsA Price:20.0

这样就得到了我们想要的结果了。

这样,对象的拷贝就讲完了吗?

哈哈哈哈,不要崩溃,并没有,还有一种更复杂的情况,那就是当你的成员变量里也包含引用类型的时候,比如Cart类中有一个CartB类的成员变量,CartB类中同样存在引用类型的成员变量,这时候,就存在多层克隆的问题了。这里再介绍一个骚操作,只需要了解即可,那就是序列化对象。操作如下:

import java.io.*;

public class Cart implements Serializable{
//实例域
Goods goodsList = new Goods("",0);//简单起见,这里只放了一个商品
double budget = 0.0;//预算 //构造函数
public Cart(double aBudget){
budget = aBudget;
} //获取预算
public double getBudget() {
return budget;
} //修改预算
public void setBudget(double aBudget) {
budget = aBudget;
} //这里只是简单的将商品进行了赋值
public void addGoods(Goods goods){
goodsList = (Goods) goods.clone();
} //这是为了演示加上的代码,仅仅将商品标题修改成新标题
public void changeGoodsTitle(String title){
goodsList.setTitle(title);
} //打印商品信息
public void print(){
System.out.print("Cart内的预算信息:"+budget+" 商品信息:");
goodsList.print();
}
  //这里是主要是骚操作
public Object deepClone() throws IOException, OptionalDataException,ClassNotFoundException {
// 将对象写到流里
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(this);
// 从流里读出来
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
return (oi.readObject());
}
}

关于这种方法我就不多做介绍了,大家只需要知道有这样一种方法就行了,以后如果遇到了需要使用这种情况,就知道该怎样处理了。

这里总结一下,对象的克隆就是把一个对象的当前状态重新拷贝一份到另一个新对象中,两个对象变量指向不同的对象,浅克隆仅仅调用super.clone()方法,对成员变量也只是简单的值拷贝,所以当成员变量中有数组,对象等复杂类型的时候,就会存在藕断丝连的混乱关系,深拷贝不仅仅调用super.clone()方法进行对象拷贝,将对象中的复杂类型同样进行了拷贝,这样两个对象就再无瓜葛,井水不犯河水了。

至此,对象的克隆就真正的结束了,欢迎大家继续关注!如有不懂的问题可以留言。也欢迎各位大佬来批评指正。喜欢我的教程的话记得动动小手点下推荐,也欢迎关注我的博客。

真正重要的东西,用眼睛是看不见的。

Java对象的克隆的更多相关文章

  1. 【JAVA零基础入门系列】Day14 Java对象的克隆

    今天要介绍一个概念,对象的克隆.本篇有一定难度,请先做好心理准备.看不懂的话可以多看两遍,还是不懂的话,可以在下方留言,我会看情况进行修改和补充. 克隆,自然就是将对象重新复制一份,那为什么要用克隆呢 ...

  2. java对象 深度克隆(不实现Cloneable接口)和浅度克隆

    详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt128 为什么需要克隆: 在实际编程过程中,我们常常要遇到这种情况:有一个对象 ...

  3. Java对象的克隆和深浅问题

    Java实现克隆的方式 Java实现克隆的方式有如下两种, 推荐采用实现Cloneable接口的方式 实现Cloneable接口, 重写clone方法, 调用父类的clone方法 还有另一种方法, 不 ...

  4. java对象的克隆以及深拷贝与浅拷贝

    一.为什么要使用克隆 在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能 会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也 ...

  5. Java的“影子克隆”和“深度克隆”

    今天来学习学习java对象的克隆,在写代码的时候,有时候我们会这样写:对象1=对象2,也就是把对象2赋值给对象1了,但是这样做有个问题,就是如果我们修改了对象2的属性值,对象1的相同属性值也被修改了, ...

  6. java对象比较器和克隆

    一.比较器Comparable和Comparator 上一篇博客介绍了工具类Arrays工具类 .我们可以对基本类型的数组调用Arrays.sort()函数来进行数组的排序.排序操作在日常开发中经常要 ...

  7. Java对象克隆(Clone)及Cloneable接口、Serializable接口的深入探讨

    Java对象克隆(Clone)及Cloneable接口.Serializable接口的深入探讨 Part I 没啥好说的,直接开始Part II吧. Part II 谈到了对象的克隆,就不得不说为什么 ...

  8. (转)Java对象克隆(Clone)及Cloneable接口、Serializable接口的深入探讨

    原文地址:http://blog.csdn.net/kenthong/article/details/5758884 Part I 没啥好说的,直接开始Part II吧. Part II 谈到了对象的 ...

  9. Java对象克隆详解

    原文:http://www.cnblogs.com/Qian123/p/5710533.html 假如说你想复制一个简单变量.很简单: int apples = 5; int pears = appl ...

随机推荐

  1. Hive和并行数据仓库的比较

    最近分析和比较了Hive和并行数据仓库的架构,本文记下一些体会. Hive是架构在Hadoop MapReduce Framework之上的开源数据分析系统. Hive具有如下特点: 1. 数据以HD ...

  2. SpringBoot使用@Value从yml文件取值为空--注入静态变量

    SpringBoot使用@Value从yml文件取值为空--注入静态变量     1.application.yml中配置内容如下:   pcacmgr:   publicCertFilePath: ...

  3. Windows 64 位 mysql 5.7.20 安装教程

    mysql 5.7以上版本包解压中没有data目录和my-default.ini和my.ini文件以及服务无法启动的解决办法以及修改初始密码的方法 mysql官网下载地址:https://dev.my ...

  4. Android系统显示原理

    Android的显示过程可以概括为:Android应用程序把经过测量.布局.绘制后的surface缓存数据,通过SurfaceFlinger把数据渲染到屏幕上,通过Android的刷新机制来刷新数据. ...

  5. vue总结2

    1. 给router-link添加事件 之前用v-link 现在用 router-link 添加事件要用原生的.native修饰v-on <my-component v-on:click.nat ...

  6. [z] Git pull 强制覆盖本地文件

    git fetch --all git reset --hard origin/master git pull git fetch 只是下载远程的库的内容,不做任何的合并 git reset 把HEA ...

  7. jquery Jquery 遍历 获取设置 效果

    speed: slow fast 毫秒 隐藏 显示 $(selector).hide(speed,callback) 隐藏. $(selector).show(speed,callback) 显示 $ ...

  8. pycharm 出现Process finished with exit code 0 或 Process finished with exit code -1

    Process finished with exit code 0 意味着你的程序正常执行完毕并退出. 可以科普一下exit code,在大部分编程语言中都适用: exit code 0 表示程序执行 ...

  9. bowtie:短序列比对的新工具

    bowtie:短序列比对的新工具(转) (2014-11-17 22:15:24) 转载▼ 标签: 转载   原文地址:bowtie:短序列比对的新工具(转)作者:玉琪星兆 Bowtie是一个超级快速 ...

  10. 浅谈多重检验校正FDR

    浅谈多重检验校正FDR Posted: 四月 12, 2017  Under: Basic  By Kai  no Comments 例如,在我们对鉴定到的差异蛋白做GO功能注释后,通常会计算一个p值 ...