浅谈java 对象克隆

我们在编码过程经常会碰到将一个对象传递给另一个对象，java中对于基本型变量采用的是值传递，而对于对象比如bean传递时采用的是应用传递也就是地址传递，而很多时候对于对象传递我们也希望能够象值传递一样，使得传递之前和之后有不同的内存地址

package com.mapbar.clone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 
 * Class CloneDemo.java
 * 
 * Description
 * 
 * Company mapbar 浅克隆，深度克隆，以及对象序列化克隆
 * 
 * author Chenll E-mail: Chenll@mapbar.com
 * 
 * Version 1.0
 * 
 * Date 2012-4-1 上午09:44:06
 */

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

class StudentA implements Cloneable {

	@Override
	public String toString() {
		return "StudentA [id=" + id + ", score=" + score + "]";
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	public StudentA(String id, double score) {
		super();
		this.id = id;
		this.score = score;
	}

	private String id;

	private double score;

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

}

// 深度克隆对象,当类存在聚合关系的时候,克隆就必须考虑聚合对象的克隆
class StudentB implements Cloneable {

	@Override
	public String toString() {
		return "StudentB [studentA=" + studentA + ", name=" + name + ", score="
				+ score + "]";
	}

	public StudentB(StudentA studentA, String name, double score) {
		super();
		this.studentA = studentA;
		this.name = name;
		this.score = score;
	}

	public StudentA getStudentA() {
		return studentA;
	}

	public void setStudentA(StudentA studentA) {
		this.studentA = studentA;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	private StudentA studentA;

	private String name;

	private double score;

	@Override
	protected Object clone() throws CloneNotSupportedException {
		StudentB sb = (StudentB) super.clone();
		// 克隆其它聚合属性
		if (this.studentA != null) {
			sb.studentA = (StudentA) this.studentA.clone();
		}
		return sb;
	}
}
	
public  class CloneDemo{
	/**
	 * 所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值再生成相同状态的对象。 这个过程也可以通过网络实现
	 */
	public static Object copyObject(Object oldObj) {
		Object newObj = null;
		try {
			ByteArrayOutputStream bo = new ByteArrayOutputStream();
			ObjectOutputStream oo = new ObjectOutputStream(bo);
			oo.writeObject(oldObj);// 源对象
			ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
			ObjectInputStream oi = new ObjectInputStream(bi);
			newObj = oi.readObject();// 目标对象
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return newObj;
	}
	
	public static void main(String[] args) throws CloneNotSupportedException{
		StudentA a = new StudentA("world",10.0);
		System.out.println("before a:"+a.toString());
		StudentA aa = (StudentA) a.clone();
		a.setId("world20");
		a.setScore(20.0);
		System.out.println("after a:"+a.toString());
		System.out.println("clone a:"+aa.toString());
		
		StudentB b = new StudentB(a,"hello",30);
		System.out.println("before b:"+b.toString());
		StudentB bb = (StudentB) b.clone();
		StudentB bbb = (StudentB) copyObject(b);
		b.getStudentA().setId("helloooo");
		b.setScore(50);
		System.out.println("after b:"+b.toString());
		System.out.println("clone b:"+bb.toString());
		System.out.println("copyObject b:"+bbb.toString());
		
		
	}
}

output:

before a:StudentA [id=world, score=10.0]
after a:StudentA [id=world20, score=20.0]
clone a:StudentA [id=world, score=10.0]
before b:StudentB [studentA=StudentA [id=world20, score=20.0], name=hello, score=30.0]
after b:StudentB [studentA=StudentA [id=helloooo, score=20.0], name=hello, score=50.0]
clone b:StudentB [studentA=StudentA [id=world20, score=20.0], name=hello, score=30.0]
copyObject b:StudentB [studentA=StudentA [id=world20, score=20.0], name=hello, score=30.0]