最近我们完成了一个优质客户的大项目，里面就用到了许多的非new创建对象的方法，现在我就项目中的要点给大家分享一下。

java创建对象的几种方式

在进行实例演示前，我们准备一个用于演示的用户类

public class user {
	public String name;
	
	public String gender;
	
	public int age;
	
	/**
	 * 兴趣
	 */
	public String interest;
	
	
	/**
	 * 无参构造方法
	 */
	public user() {
		// TODO Auto-generated constructor stub
	}
public user(String name,String gender,int age,String interest) {
		this.name=name;
		this.age=age;
		this.gender=gender;
		this.interest=interest;
	}
	
}

第一种最常见: 使用new

public class DemoClass {
	public static void main(String[] args) {
		
		user user1=new user(); //无参构造
		user user2=new user("小张","男",14,"健身"); //有参构造
	}
}

使用new可以快速的创建对象。而且也可以随意构造无参数和有参数的构造函数，new是最常用也是用的最多的；

使用new（）的优点：

new: 强类型。相对高效。能调用任何public构造。

第二种使用Class. newInstance()

public class DemoClass {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
		
		Class userc=user.class;
		user user3=(user)userc.newInstance();		
	}
}

这样获取到类对象之后就可以通过newInstance()这个方法来获取具体的对象了，需要注意的是这个方法的返回值是Object类型，我们需要进行转型操作

不过使用class.newinstnace这种方法有缺点：

class.newInstance: 它是弱类型。效率低下。并且只能调用无参构造。

第三种 使用 Constructor 类的 newInstance()

public class DemoClass {
	public static void main(String[] args) throws InstantiationException, IllegalArgumentException, InvocationTargetException {
		
		Constructor constructorUser=user.class.getConstructor();
		user user4=(user) constructorUser.newInstance();
		
 //使用有参数构造函数
 Constructor constructoruser1=
 user.class.getConstructor(String.class,String.class,int.class,String.class);		
		 user user5=(user)constructoruser1.newInstance("老王","男",24,"羽毛球");
	}
}

不管是使用Class.newInstance方法或是使用Constructor .newInstance。Class.newInstance的内部构造其实是使用Constructor .newInstance的方式创建对象.

使用Constructor 的newInstance比使用class.newInstance更受欢迎，因为它可以创建无参数或者有参数的构造函数

第四种.使用 Clone() 方法

clone方法来源于java中object类，在jdk中的解释为：该方法返回一个此对象的副本。clone顾名思义就是复制的意思。所谓复制对象就是在内存中分配一个和原一模一样的空间，在此创建新的对象。

要想使用Clone首先我们需要在需要clone的类中实现Cloneable接口，

public class user implements Cloneable {
	public String name;
	
	public String gender;
	
	public int age;
	
	/**
	 * 兴趣
	 */
	public String interest;
	
	
	/**
	 * 无参构造方法
	 */
	public user() {
		// TODO Auto-generated constructor stub
	}
	
	public user(String name,String gender,int age,String interest) {
		this.name=name;
		this.age=age;
		this.gender=gender;
		this.interest=interest;
	}
	
//实现接口
protected Object clone() throws CloneNotSupportedException{
		
		
		return super.clone();
		
	}
	
	}

接着在代码中clone一个user

public class DemoClass {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
		
		user user1=new user(); //无参构造
		user user2=new user("小张","男",14,"健身"); //有参构造
		
		
	 //克隆一个user1对象
	 user user6=(user)user1.clone();
	}		
}

如果我们比较user1==user6 会返回false

因为clone是真实在内存中重新划分一块区域来存储新的对象，user1和user2是两个不同的对象所以返回结果值为false

第五中5.使用 deserialization 序列化

每当我们序列化和反序列化对象时，JVM会为我们创建了一个独立的对象。在 deserialization 中，JVM 不使用任何构造函数来创建对象。

使用序列化时，要实现实现Serializable接口，将一个对象序列化到磁盘上，而采用反序列化可以将磁盘上的对象信息转化到内存中。

对于序列化对象，我们需要在类中实现 Serializable 接口。

public class User1 implements Serializable{
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

接下来反序列化对象

public class SerializableDemo1 {
	public static void main(String[] args) throws Exception, IOException {
		//初始化对象
	User1 user = new User1();
 user.setName("yaomy");
 user.setAge(23);
 System.out.println(user);
 //序列化对象到文件中
 ObjectOutputStream oos = 
 new ObjectOutputStream(new FileOutputStream("template"));
 oos.writeObject(user);
 oos.close();
 //反序列化
 File file = new File("template");
 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
 User1 newUser = (User1)ois.readObject();
 System.out.println(newUser.toString());
	}
}

以上就是在项目中经常使用到的5种对象使用方法，其实关于序列化对象还有一种方法就是被序列化对象实现Externalizable接口。

Externalizable接口和Serializable接口的区别：

Externalizable继承了Serializable

该接口中定义了两个抽象方法：writeExternal()与readExternal()。

当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法。

实现Externalizable接口的类必须要提供一个public的无参的构造器。

由于篇幅原因未能给出代码示范，大家可以私下自己尝试动手写出代码。

你们还能找出其他创建对象的方法吗？