一 前言
Java是面向对象的编程语言，作为Java开发人员，我们每天都会创建许多对象.只要代码中用到，就需要创建对象。
Java语言中，创建对象基本的方法有6种，下面我们来一一地在回顾一下。
二 基本的方法
（1）使用new关键字
Personp1=newPerson();
（2）反射之Class类newInstance()
Personp2=Person.class.newInstance();
（3）反射之Constructor类的newInstance()
Personp3=Person.class.getDeclaredConstructor().newInstance();
（4）Object对象的clone方法
Personp4= (Person) p1.clone();
注意事项：
a、注意Object类的clone方法是protected的，在Override的时候，可以改成public，这样让其它所有类都可以调用。
b、注意浅拷贝和深拷贝。
（5）反序列化
ObjectOutputStreamoos=newObjectOutputStream(newFileOutputStream("object.bin")); oos.writeObject(p1); oos.close(); ObjectInputStreamois=newObjectInputStream(newFileInputStream("object.bin")); Personp5= (Person) ois.readObject(); ois.close();
注意事项：
a、必须要实现Serializable接口；
b、需要注意哪些字段可序列化，哪些字段不会被序列化，如何控制；
c、注意serialVersionUID的作用;
（6）使用Unsafe类
Fieldf=Unsafe.class.getDeclaredField("theUnsafe"); f.setAccessible(true); Unsafeunsafe= (Unsafe) f.get(null); Personp6= (Person) unsafe.allocateInstance(Person.class);
*注意：此方法一般不常用，只是作为知识框架的补充提及。
基本方法小结
1、正常创建：通过
new操作符;2、反射创建：调用
Class或java.lang.reflect.Constructor的newInstance()方法;3、克隆创建：调用现有对象的
clone()方法;4、反序列化：调用
java.io.ObjectInputStream的getObject()方法反序列化;5、
使用Unsafe类：不常用的方法
三 优雅的方式
Java对象的创建方式是其语法明确规定，用户不可能从外部改变的。本文仍然要使用上面的方式来创建对象，只是方式更高级、更优雅！
假设有这样一个场景，现在要构建一个大型的对象，这个对象包含许多个参数的对象，有些参数有些是必填的，有些则是选填的。那么如何构建优雅、安全地构建这个对象呢？
方式一：单一构造函数
通常，我们第一反应能想到的就是单一构造函数方式。直接new的方式构建，通过构造函数来传递参数，见下面的代码：
/*** 单一构造函数*/publicclassPerson01 { // 姓名(必填)privateStringname; // 年龄(必填)privateintage; // 身高(选填)privateintheight; // 学校(选填)privateStringschool; // 爱好(选填)privateStringhobby; publicPerson01(Stringname, intage, intheight, Stringschool, Stringhobby) { this.name=name; this.age=age; this.height=height; this.school=school; this.hobby=hobby; } }
上面的构建方式有下面的缺点：
1、有些参数是可以选填的（如
height,school），在构建Person的时候必须要传入可能并不需要的参数。2、现在上面才5个参数，构造函数就已经非常长了。如果是20个参数，写出来的代码可读性、可维护性就会非常差。
3、构建的这样的对象非常容易出错。客户端必须要对照
Javadoc或者参数名来讲实参传入对应的位置。如果参数都是String类型的，一旦传错参数，编译是不会报错的，但是运行结果却是错误的。
方式二：多构造函数
/*** 多构造函数*/publicclassPerson02 { // 姓名(必填)privateStringname; // 年龄(必填)privateintage; // 身高(选填)privateintheight; // 学校(选填)privateStringschool; // 爱好(选填)privateStringhobby; publicPerson02(Stringname, intage) { this.name=name; this.age=age; } publicPerson02(Stringname, intage, intheight) { this.name=name; this.age=age; this.height=height; } publicPerson02(Stringname, intage, intheight, Stringschool) { this.name=name; this.age=age; this.height=height; this.school=school; } publicPerson02(Stringname, intage, intheight, Stringschool, Stringhobby) { this.name=name; this.age=age; this.height=height; this.school=school; this.hobby=hobby; } }
上面的方式确实能在一定程度上降低构造函数的长度，但是却有下面的缺陷：
1、导致类过长：这种方式会使得Person类的构造函数成阶乘级增长。按理来说，应该要写的构造函数数是可选成员变量的组合数。如果让其他人调用这样的类，绝对会在心里默念xx!!
2、有些参数组合无法重构。因为Java中重载是有限制的，相同方法签名的方法不能构成重载，编译时无法通过。譬如包含（name,age,school）和(name,age,hobby)的构造函数是不能重载的，因为
shcool和hobby同为String类型。Java只认变量的类型，不认变量的含义。
方式三：JavaBean方式
直接上代码：
/*** javaBean 方式创建对象*/publicclassPerson03 { // 姓名(必填)privateStringname; // 年龄(必填)privateintage; // 身高(选填)privateintheight; // 学校(选填)privateStringschool; // 爱好(选填)privateStringhobby; publicPerson03(Stringname, intage) { this.name=name; this.age=age; } publicvoidsetHeight(intheight) { this.height=height; } publicvoidsetSchool(Stringschool) { this.school=school; } publicvoidsetHobby(Stringhobby) { this.hobby=hobby; } }
客户端使用这个对象的代码如下：
/*** 使用Person03 对象的客户端*/publicclassClient03 { publicstaticvoidmain(String[] args) { Person03person03=newPerson03("xiaoliu",12); person03.setHeight(170); person03.setSchool("北京大学"); person03.setHobby("读书"); } }
这样看起来完美的解决了Person对象构建的问题，使用起来非常优雅便捷。确实，在单一线程的环境中这确实是一个非常好的构建对象的方法，但是如果是在多线程环境中仍有其致命缺陷。
在多线程环境中，这个对象不能安全地被构建，因为它不是不可变对象。一旦Person对象被构建，我们随时可通过setXXX()方法改变对象的内部状态。假设有一个线程正在执行与Person对象相关的业务方法，另外一个线程改变了其内部状态，这样得到莫名其妙的结果。由于线程运行的无规律性，使得这问题有可能不能重现.
方式四：Builder 方式
为了完美地解决这个问题，我们使用构建器（Builder）来优雅、安全地构建Person对象。直接上代码：
/*** Builder 方式*/publicclassPerson04 { // 姓名(必填)privatefinalStringname; // 年龄(必填)privatefinalintage; // 身高(选填)privatefinalintheight; // 学校(选填)privatefinalStringschool; // 爱好(选填)privatefinalStringhobby; /*** 这个私有构造函数的作用:* 1、成员变量的私有化，final 类型的变量必须进行初始化，否则无法编译成功* 2、私有构造函数能够保证该对象无法从外部创建，并且person类无法被继承* @param name* @param age* @param height* @param school* @param hobby*/privatePerson04(Stringname, intage, intheight, Stringschool, Stringhobby) { this.name=name; this.age=age; this.height=height; this.school=school; this.hobby=hobby; } publicvoiddoSomeThing(){ //todo do what you want! } /*** 构建器* 为什么Builder是内部静态类？* 1、必须是person的内部类，否则，由于Person的构造函数私有，不能通过new的方式创建对象；* 2、必须是静态类，由于Person对象无法从外部创建，如果不是静态类，则外部无法引用Builder对象；* 注意：Builder的内部成员变量要与Person的成员变量保持一致*/publicstaticclassBuilder{ // 【这里成员变量不能是final的】// 姓名(必填)privateStringname; // 年龄(必填)privateintage; // 身高(选填)privateintheight; // 学校(选填)privateStringschool; // 爱好(选填)privateStringhobby; publicBuilder(Stringname,intage){ this.name=name; this.age=age; } publicBuildersetHeight(intheight) { this.height=height; returnthis; } publicBuildersetSchool(Stringschool) { this.school=school; returnthis; } publicBuildersetHobby(Stringhobby) { this.hobby=hobby; returnthis; } /*** 构建对象* 返回待够贱的对象本身* @return*/publicPerson04build(){ returnnewPerson04(name,age,height,school,hobby); } } }
客户端使用这个对象的代码如下：
/*** 使用 Person04 对象的客户端*/publicclassClient04 { publicstaticvoidmain(String[] args) { /*** 通过链式调用的方式创建Person对象，非常优雅！*/Person04person04=newPerson04 .Builder("xiaoliu",25) .setHeight(175) .setSchool("北京大学") .setHobby("reading") .build(); person04.doSomeThing(); } }
通过privatePerson(..)使得Person类不可被继承;
通过将Person类的成员变量设置为final类型，使得其不可变;
通过Person内部的static Builder类来构建Person对象;
通过将Builder类内部的setXXX()方法返回Builder类型本身，实现链式调用构建Person对象;
至此，我们就相对完美地解决这一类型的对象创建问题！总结待创建的对象特点：
1、需要用户手动的传入多个参数，并且有多个参数是可选的、顺序任意;
2、对象不可变；
3、对象所属的类不是为了继承而设计的，即类不能被继承；
四 总结
本文介绍了java独享创建的6中基本方法，引申出复杂非业务场景如何优雅地创建对象这一问题，我们依次使用的对象构建方法如下：
1、单一构造函数
2、多构造函数
3、JavaBean方式
4、Builder方式
最终，通过比较得出Builder方法最为合适的解决办法。
五 参考
感谢前人的经验、分享和付出，让我们可以有机会站在巨人的肩膀上眺望星辰大海！
