Java 创建对象的四种方法

package com.lou.creation;

public class Client {

	public static void main(String[] args) {
		//1.使用new 方式创建对象
		Worker worker1 = CreateInstanceUtil.createWorker();
		Worker worker2 = CreateInstanceUtil.createWorker("Louis", 23);
		
		//2.使用反射机制进行创建：
		//a.使用反射机制，不带参数 Class 對象的 newInstance() 方法
		Worker worker3 = CreateInstanceUtil.createWorker1();
		
		//b.使用反射機制 ， Constructor的 newInstance方法 不带参数
		Worker worker4 = CreateInstanceUtil.createWorker2();
		
		//c.使用反射机制 ：带参数的构造函数创建新对象
		Worker worker5 = CreateInstanceUtil.createWorker3("Louis", 23);
		
		//3. 使用序列化和反序列化 进行创建，这个实际上是对象的复原
		//将一个对象存入lou.dat文件内
		CreateInstanceUtil.storeObject2File("lou.dat");
		//将对象从文件取出
		Worker worker6 = CreateInstanceUtil.createWorker4("lou.dat");
	
		//4.利用对象的深层拷贝功能
		
		Worker worker7 = CreateInstanceUtil.createWorker5(worker1);
		
	}
}

 

 

package com.lou.creation;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class CreateInstanceUtil {

	/*
	 * 方式1： 直接使用new的方式,不使用参数
	 */
	public static Worker createWorker() {
		return new Worker();
	}

	/*
	 * 方式2： 使用new方式，带参数
	 */
	public static Worker createWorker(String name, int age) {
		return new Worker(name, age);
	}

	/*
	 * 方式3： 使用反射机制，不带参数 Class 對象的 newInstance() 方法
	 */

	public static Worker createWorker1() {

		Class clazz = null;
		Worker worker = null;
		try {
			clazz = Class.forName("com.lou.creation.Worker");
			worker = (Worker) clazz.newInstance();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

		return worker;
	}

	/*
	 * 方式4： 使用反射機制 ， Constructor的 newInstance方法
	 */

	public static Worker createWorker2() {
		Worker worker = null;
		try {
			Class clazz = null;
			clazz = Class.forName("com.lou.creation.Worker");

			// 获取不带参数的构造器
			Constructor constructor = clazz.getConstructor();
			// 使用构造器创建对象
			worker = (Worker) constructor.newInstance();

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}

		return worker;
	}

	/*
	 * 方式5： 使用反射机制 ：带参数的构造函数创建新对象
	 */
	public static Worker createWorker3(String name, Integer age) {
		Worker worker = null;
		try {
			Class clazz = null;
			clazz = Class.forName("com.lou.creation.Worker");

			// 获取不带参数的构造器
			Constructor constructor = clazz.getConstructor(name.getClass(),
					age.getClass());
			// 使用构造器创建对象
			worker = (Worker) constructor.newInstance(name, age);

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return worker;
	}

	/*
	 * 方式6： 使用序列化和反序列化创建对象，这种方式其实是根据既有的对象进行复制，这个需要事先将可序列化的对象线存到文件里
	 */
	@SuppressWarnings("resource")
	public static Worker createWorker4(String objectPath) {
		ObjectInput input = null;
		Worker worker = null;
		try {
			input = new ObjectInputStream(new FileInputStream(objectPath));
			worker = (Worker) input.readObject();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return worker;
	}

	/*
	 * 将创建的对象存入到文件内
	 */
	public static void storeObject2File(String objectPath) {
		Worker worker = new Worker();
		ObjectOutputStream objectOutputStream;
		try {
			objectOutputStream = new ObjectOutputStream(new FileOutputStream(
					objectPath));
			objectOutputStream.writeObject(worker);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/*
	 * 方式7， 使用对象的 深复制进行复制，创建对象
	 */
	public static Worker createWorker5(Worker worker) {
		return (Worker) worker.clone();
	}
	
	public static void main(String[] args) {
		
	}

}

 

package com.lou.creation;

import java.io.Serializable;

public class Worker implements Cloneable,Serializable {

	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	
	public Worker()
	{
		this.name = "";
		this.age = 0;
	}
	
	public Worker(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public void work()
	{
		System.out.println(name +"is working");
	}
	
	public Worker clone()
	{
		Worker worker = null;
		try {
			return (Worker) super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return worker;
	}
}