一 前言
Java是面向对象的编程语言，作为Java开发人员，我们每天都会创建许多对象.只要代码中用到，就需要创建对象。
Java语言中，创建对象基本的方法有 6 种，下面我们来一一地在回顾一下。
二 基本的方法
（1）使用new关键字
Person p1 = new Person();
复制代码
（2）反射之Class类newInstance()
Person p2 = Person.class.newInstance();
复制代码
（3）反射之Constructor类的newInstance()
Person p3 = Person.class.getDeclaredConstructor().newInstance();
复制代码
（4）Object对象的clone方法
Person p4 = (Person) p1.clone();
复制代码
注意事项：
a、注意Object类的clone方法是protected的，在Override的时候，可以改成public，这样让其它所有类都可以调用。
b、注意浅拷贝和深拷贝。
（5）反序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.bin"));oos.writeObject(p1);oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.bin"));Person p5 = (Person) ois.readObject();ois.close();
复制代码
注意事项：
a、必须要实现Serializable接口；
b、需要注意哪些字段可序列化，哪些字段不会被序列化，如何控制；
c、注意serialVersionUID的作用;
（6）使用 Unsafe 类
Field f = Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(true);Unsafe unsafe = (Unsafe) f.get(null);Person p6 = (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 的方式构建，通过构造函数来传递参数，见下面的代码：
/** * 单一构造函数 */public class Person01 {
// 姓名(必填) private String name;
// 年龄(必填) private int age;
// 身高(选填) private int height;
// 学校(选填) private String school;
// 爱好(选填) private String hobby;
public Person01(String name, int age, int height, String school, String hobby) { 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 类型的，一旦传错参数，编译是不会报错的，但是运行结果却是错误的。
方式二：多构造函数
/** * 多构造函数 */public class Person02 {
// 姓名(必填) private String name;
// 年龄(必填) private int age;
// 身高(选填) private int height;
// 学校(选填) private String school;
// 爱好(选填) private String hobby;
public Person02(String name, int age) { this.name = name; this.age = age; }
public Person02(String name, int age, int height) { this.name = name; this.age = age; this.height = height; }
public Person02(String name, int age, int height, String school) { this.name = name; this.age = age; this.height = height; this.school = school; }
public Person02(String name, int age, int height, String school, String hobby) { 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 方式创建对象 */public class Person03 {
// 姓名(必填) private String name;
// 年龄(必填) private int age;
// 身高(选填) private int height;
// 学校(选填) private String school;
// 爱好(选填) private String hobby;
public Person03(String name, int age) { this.name = name; this.age = age; }
public void setHeight(int height) { this.height = height; }
public void setSchool(String school) { this.school = school; }
public void setHobby(String hobby) { this.hobby = hobby; }}
复制代码
客户端使用这个对象的代码如下：
/** * 使用Person03 对象的客户端 */public class Client03 {
public static void main(String[] args) { Person03 person03 = new Person03("xiaoliu",12); person03.setHeight(170); person03.setSchool("北京大学"); person03.setHobby("读书"); }}
复制代码
这样看起来完美的解决了 Person 对象构建的问题，使用起来非常优雅便捷。确实，在单一线程的环境中这确实是一个非常好的构建对象的方法，但是如果是在多线程环境中仍有其致命缺陷。
在多线程环境中，这个对象不能安全地被构建，因为它不是不可变对象。一旦 Person 对象被构建，我们随时可通过setXXX()方法改变对象的内部状态。假设有一个线程正在执行与Person对象相关的业务方法，另外一个线程改变了其内部状态，这样得到莫名其妙的结果。由于线程运行的无规律性，使得这问题有可能不能重现.
方式四：Builder 方式
为了完美地解决这个问题，我们使用构建器（Builder）来优雅、安全地构建 Person 对象。直接上代码：
/** * Builder 方式 */public class Person04 {
// 姓名(必填) private final String name;
// 年龄(必填) private final int age;
// 身高(选填) private final int height;
// 学校(选填) private final String school;
// 爱好(选填) private final String hobby;
/** * 这个私有构造函数的作用: * 1、成员变量的私有化，final 类型的变量必须进行初始化，否则无法编译成功 * 2、私有构造函数能够保证该对象无法从外部创建，并且person类无法被继承 * @param name * @param age * @param height * @param school * @param hobby */ private Person04(String name, int age, int height, String school, String hobby) { this.name = name; this.age = age; this.height = height; this.school = school; this.hobby = hobby; }
public void doSomeThing(){ //todo do what you want! }
/** * 构建器 * 为什么Builder是内部静态类？ * 1、必须是person的内部类，否则，由于Person的构造函数私有，不能通过new的方式创建对象； * 2、必须是静态类，由于Person对象无法从外部创建，如果不是静态类，则外部无法引用Builder对象； * 注意：Builder的内部成员变量要与Person的成员变量保持一致 */ public static class Builder{
// 【这里成员变量不能是final的】 // 姓名(必填) private String name;
// 年龄(必填) private int age;
// 身高(选填) private int height;
// 学校(选填) private String school;
// 爱好(选填) private String hobby;
public Builder(String name,int age){ this.name = name; this.age = age; }
public Builder setHeight(int height) { this.height = height; return this; }
public Builder setSchool(String school) { this.school = school; return this; }
public Builder setHobby(String hobby) { this.hobby = hobby; return this; }
/** * 构建对象 * 返回待够贱的对象本身 * @return */ public Person04 build(){ return new Person04(name,age,height,school,hobby); } }}
复制代码
1、通过 privatePerson(..)使得 Person 类不可被继承;
2、通过将 Person 类的成员变量设置为 final 类型，使得其不可变;
3、通过 Person 内部的 static Builder 类来构建 Person 对象;
4、通过将 Builder 类内部的 setXXX()方法返回 Builder 类型本身，实现链式调用构建 Person 对象;
至此，我们就相对完美地解决这一类型的对象创建问题！总结待创建的对象特点：
1、需要用户手动的传入多个参数，并且有多个参数是可选的、顺序任意;
2、对象不可变；
3、对象所属的类不是为了继承而设计的，即类不能被继承；
四 总结
本文介绍了 java 创建对象的 6 种基本方法，引申出复杂业务场景中如何优雅地创建对象这一问题，我们依次使用的对象构建方法如下：
1、单一构造函数
2、多构造函数
3、JavaBean 方式
4、Builder 方式
最终，通过比较得出 Builder 方法最为合适的解决办法。
五 参考
Java创建对象的六种方法-权当记录一下
感谢前人的经验、分享和付出，让我们可以有机会站在巨人的肩膀上眺望星辰大海！
评论