通过本文主要向大家介绍了c语言是一种,c语言是一种什么语言,已知一种c h,c语言编译器是一种,c是一种合成树脂等相关知识,希望对您有所帮助,也希望大家支持linkedu.com www.linkedu.com
楼主是一名asp.net攻城狮，最近经常跑java组客串帮忙开发，所以最近对java的一些基础知识特别上心。却遇到需要将一个对象深拷贝出来做其他事情，而原对象保持原有状态的情况。（实在是不想自己new一个出来，然后对着一堆字段赋值......好吧，再此之前我没有关心是否项目框架有深拷贝的方法），然后就想着用反射实现吧....接下来
是我自己的原因，还是真的不存在这样的纯用反射实现的深拷贝方式....（c#是有纯反射实现的）
但也不能算自己白忙活吧，也找到了其他实现深拷贝的方式（但是每种方式我都觉得并不是太合理，也许是因为c#的方式带入了吧，最后贴出c#版本纯反射实现深拷贝的代码）
方式一：实现Cloneable接口，重写clone方法
实体类：一个轮胎类，一个车辆类，车辆中包含轮胎
/**轮胎类**/
public class Tire implements Cloneable {
public String color;
public int radius;
public Tire(){}
public Tire(String color, int radius) {
this.color = color;
this.radius = radius;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/**车辆类**/
public class Car implements Cloneable{
public String name;
public String color;
public Tire tire;
public Car() {}
public Car(String name, String color, Tire tire) {
this.name = name;
this.color = color;
this.tire = tire;
}
public void whistle(){
System.out.println("汽车"+this.name+" 鸣笛...");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Tire getTire() {
return tire;
}
public void setTire(Tire tire) {
this.tire = tire;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
</div>
@Test
public void test() throws CloneNotSupportedException {
Tire tire = new Tire("black",100);
Car car = new Car("奔驰","white",tire);
Car car_copy = (Car)car.clone();
System.out.println("car:"+car.hashCode()+" car.tire:"+car.tire.hashCode());
System.out.println("car_copy:"+car_copy.hashCode()+" car_copy.tire:"+car_copy.tire.hashCode());
car_copy.color = "blue";
System.out.println("car_copy:"+car_copy.color+" car:"+car.color);
}
</div>
输出结果：
car:1223737555 car.tire:906199566 car_copy:542081238 car_copy.tire:906199566 car_copy:blue car:white</div>
从结果可以的之，car与car_copy的内存地址并不一致，但car.tire与car_copy.tire的内存地址却是一致的，说明“奔驰”车确实又造出了一辆，但却公用同一幅轮胎（这种情形....哈哈哈），好吧，也就是只复制了tire的引用，这可以说是深拷贝的不彻底 （hashCode()的值可以当作是内存地址来理解），那么要怎样才能彻底，真正的深拷贝？
修改Car类中的clone方法：
@Override
protected Object clone() throws CloneNotSupportedException {
Car car = (Car)super.clone();
car.tire = (Tire)car.tire.clone();
return car;
}
</div>
输出结果：
car:1223737555 car.tire:906199566 car_copy:542081238 car_copy.tire:1133736492 car_copy:blue car:white</div>
这样最终实现了，但这种方式用到项目中并不是很合适吧，每个需要深拷贝的类，都要实现Cloneable接口，并覆盖其clone方法，遇到引用其他类时候更是需要修改clone方法，要是引用其他类，其他类再引用其他类呢？这不好吧......
方式二：通过序列化与反序列化实现(实现Serializable接口)
实体类：与第一种方式类似，换成实现Serializable接口，去掉clone方法
/**轮胎类**/
@SuppressWarnings("serial")
public class Tire implements java.io.Serializable {
public String color;
public int radius;
public Tire(){}
public Tire(String color, int radius) {
this.color = color;
this.radius = radius;
}
}
/**车辆类**/
@SuppressWarnings("serial")
public class Car implements java.io.Serializable{
public String name;
public String color;
public Tire tire;
public Car() {}
public Car(String name, String color, Tire tire) {
this.name = name;
this.color = color;
this.tire = tire;
}
public void whistle(){
System.out.println("汽车"+this.name+" 鸣笛...");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Tire getTire() {
return tire;
}
public void setTire(Tire tire) {
this.tire = tire;
}
}
</div>
深拷贝方法：
@SuppressWarnings("unchecked")
public static Object deepClone(Object obj)
{
Object copyObj = null;
ObjectOutputStream out = null;
ObjectInputStream in = null;
try {
// 序列化
ByteArrayOutputStream bufferOut = new ByteArrayOutputStream();
out = new ObjectOutputStream(bufferOut);
out.writeObject(obj);
// 反序列化
ByteArrayInputStream bufferIn = new ByteArrayInputStream(bufferOut.toByteArray());
in = new ObjectInputStream(bufferIn);
copyObj = in.readObject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}finally{
try{
if(in != null){
in.close();
}
if(out!=null){
out.close();
}
}catch(IOException e){
throw new RuntimeException(e);
}
}
return copyObj;
}
</div>
单元测试：
@Test
public void test() throws CloneNotSupportedException {
Tire tire = new Tire("black",100);
Car car = new Car("奔驰","white",tire);
Car car_copy = (Car)deepClone(car);
System.out.println("car:"+car.hashCode()+" car.tire:"+car.tire.hashCode());
System.out.println("car_copy:"+car_copy.hashCode()+" car_copy.tire:"+car_copy.tire.hashCode());
car_copy.color = "blue";
System.out.println("car_copy:"+car_copy.color+" car:"+car.color);
}
</div>
输出结果：
car:2019524978 car.tire:855703640 car_copy:1407965019 car_copy.tire:545768040 car_copy:blue car:white</div>
从结果集中可以看出是深拷贝是正确的，但是每个类还是需要实现Serializable，好像也不合适吧......
优化一下深拷贝方法：将其换成泛型，这样拷贝出来就不需要强转了（好吧，其实也没比上面的方法好到哪去...）
@SuppressWarnings("unchecked")
public static <T> T deepClone(T obj)
{
T copyObj = null;
ObjectOutputStream out = null;
ObjectInputStream in = null;
try {
// 序列化
ByteArrayOutputStream bufferOut = new ByteArrayOutputStream();
out = new ObjectOutputStream(bufferOut);
out.writeObject(obj);
// 反序列化
ByteArrayInputStream bufferIn = new ByteArrayInputStream(bufferOut.toByteArray());
in = new ObjectInputStream(bufferIn);
copyObj = (T)in.readObject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}finally{
try{
if(in != null){
in.close();
}
if(out!=null){