java中创建对象的几种方法

这是前段时间在某本书上看到的文章，具体是什么书名我也忘了。只记得当时做了记录。

最常见的就是通过new的方式来创建对象，这种方式通过调用构造方法来完成。除此之外，还有以下三种方式可以创建对象。

方法1：通过调用对象的clone方法

package com.howard.demo.constructobject;
/**
 * 不通过new方式创建对象 方法1：
 * 调用对象的clone方法
 * 实现clone的类首先需要继承Cloneable接口，该接口是一个标识接口，无任何接口方法。
 * 类中重写clone方法
 * 在clone方法中调用
 * 结果可以看出 创建了新的对象 但没有调用构造方法
 * 2017年8月10日
 * @author howard
 */
public class Test1 {
	public static void main(String[] args) {
		Obj obj_1 = new Obj();
		Obj obj_2 = (Obj)obj_1.clone();
		obj_1.changeInt();
		System.out.println("obj_1:"+obj_1.getAint());
		System.out.println("obj_2:"+obj_2.getAint());
	}
}
class Obj implements Cloneable {
	private int aInt = 0;
	public Obj() {
		System.out.println("construct");
	}
	public int getAint() {
		return aInt;
	}
	public void setAint(int aInt) {
		this.aInt = aInt;
	}
	public void changeInt() {
		this.aInt = 1;
	}
	@Override
	protected Object clone(){
		Object o = null;
		try {
			o = (Obj)super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return o;
	}
	
}

运行结果：

可以看出并没有调用构造方法。并且不是同一个对象。

方法2：通过反射机制

package com.howard.demo.constructobject;
/**
 * 不通过new方式创建对象 方法2：
 * 通过反射机制创建对象
 * 2017年8月10日
 * @author howard
 */
public class Test2 {
	public static void main(String[] args) {
		Class clazz;
		try {
			clazz = Class.forName("com.howard.demo.constructobject.Person");
			Person p = (Person) clazz.newInstance();
			System.out.println(p);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class Person {
	String name = "howard";
	public Person() {
		System.out.println("construct");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}
	
}





运行结果：

这种方式也调用了构造方法。


方法3：通过反序列化
package com.howard.demo.constructobject;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 不通过new方式创建对象 方法3：
 * 通过反序列化方式创建对象
 * 2017年8月10日
 * @author howard
 */
public class Test3 implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private String name;
	public Test3() {
		this.name = "howard";
		System.out.println("construct");
	}
	@Override
	public String toString() {
		return "Test3 [name=" + name + "]";
	}
	public static void main(String[] args) {
		Test3 t = new Test3();
		System.out.println(t);
		ObjectOutputStream oos = null;
		ObjectInputStream ois = null;
		try {
			FileOutputStream fos = new FileOutputStream("test3");
			oos = new ObjectOutputStream(fos);
			oos.writeObject(t);
			oos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		Test3 tt ;
		try {
			FileInputStream fis = new FileInputStream("test3");
			ois = new ObjectInputStream(fis);
			tt = (Test3)ois.readObject();
			System.out.println(tt);
			if (tt != t) {
				System.out.println("two different object");
			}
			ois.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	

}
运行结果：




这种方式没有调用构造方法，是通过序列化为本地磁盘文件，在反序列化创建的对象。