生成对象-new、clone、序列化、反射

生成对象的四种方式

（1）通过new生成对象。这是我们最常用的方式，生成的对象置于内存中的堆空间中，堆空间的构成如下图所示

一个old区，一个eden区，两个survivor区。通常生成的对象会置于Eden区中，但是当生成的对象过大，超过jvm设置的一个值的时候，也会将该对象直接置于old区中。具体的关于创建对象时，jvm对于内存分配以及内存回收的相关知识，这里也就不再累述了。
 （2）利用clone复制对象，完成生成对象。

利用clone，在内存中进行数据块的拷贝，复制已有的对象，也是生成对象的一种方式。前提是类实现Cloneable接口，Cloneable接口没有任何方法，是一个空接口，也可以称这样的接口为标志接口，只有实现了该接口，才会支持clone操作。有的人也许会问了，java中的对象都有一个默认的父类Object。Object中有一个clone方法，为什么还必须要实现Cloneable接口呢，这就是cloneable接口这个标志接口的意义，只有实现了这个接口才能实现复制操作，因为jvm在复制对象的时候，会检查对象的类是否实现了Cloneable这个接口，如果没有实现，则会报CloneNotSupportedException异常。类似这样的接口还有Serializable接口、RandomAccess接口等。还有值得一提的是在执行clone操作的时候，不会调用构造函数。还有clone操作还会面临深拷贝和浅拷贝的问题。关于这方面的问题，网上有很多的相关知识了，不再累述了。由于通过复制操作得到对象不需要调用构造函数，只是内存中的数据块的拷贝，那是不是拷贝对象的效率是不是一定会比new的时候的快。答案：不是。显然jvm的开发者也意识到通过new方式来生成对象占据了开发者生成对象的绝大部分，所以对于利用new操作生成对象进行了优化。例如

public class Person implements Cloneable {

	private String name;
	
	private String address;
	
	public Person(String name,String address){
		this.name=name;
		this.address=address;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
	public Object clone(){
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			throw new Error();
		}
	}
	public static void main(String[] args) throws Throwable {
		final int maxLoops=100000;
		long start=System.nanoTime();
		Person person = new Person("iteye", "iteye");
		for(int i=0;i<maxLoops;i++){
			person.clone();
		}
		long mid=System.nanoTime();
		System.out.println("利用clone生成10万个对象花的时间是："+(mid-start)+"ns");
		for(int i=0;i<maxLoops;i++){
			new Person("iteye", "iteye");
		}
		System.out.println("利用clone生成10万个对象花的时间是："+(System.nanoTime()-mid)+"ns");
	}
}

 得到的结果是：

利用clone生成10万个对象花的时间是：16695411ns

利用new生成10万个对象花的时间是：1668425ns

很显然还是new的效率高一些。但是这也并不是说复制的方式没有用。在构建一些复杂对象的时候，或者通过构造函数构造对象比较麻烦的时候，可以考虑这种方式。

（3）通过序列化生成对象

通过序列化方式生成对象是通过在内存中，将对象写入字节流，再从字节流中将其读取出来，这样就可以重建一个新对象，通过这种方式生成的对象与母对象之间不存在引用共享的问题，也就是相当于深拷贝了一个对象。

public class CloneUtils{
	
	public static <T extends Serializable> T clone(T obj){
		T cloneObj=null;
		
		try{
			ByteArrayOutputStream baos= new ByteArrayOutputStream();
			ObjectOutputStream oos= new ObjectOutputStream(baos);
			oos.writeObject(obj);
			oos.close();
			
			ByteArrayInputStream bais= new ByteArrayInputStream(baos.toByteArray());
			ObjectInputStream ois= new ObjectInputStream(bais);
			
			cloneObj=(T)ois.readObject();
			ois.close();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		return cloneObj;
	}
}

 以上代码提供了一个可以利用序列化方式生成对象的工具类。当然序列化本身的知识还有很多，读者请自行查阅相关资料。（注：Serializable也是接口，在第二种生成对象的方式中提到过）

 （4）可以通过反射，利用class对象生成对象。

评论

4 楼 MrLee23 2013-07-05  

深拷贝的思路不错，值得借鉴

3 楼 raph_java 2013-07-05  

我再去研究下JDK动态代理是不是也算？

2 楼 ddlgyq 2013-07-04  

steafler 写道

还有一种就是反射也可创建对象

正解

1 楼 steafler 2013-07-04  

还有一种就是反射也可创建对象