「 Java基础-对象 」一篇文章讲清楚Java开发中如何更优雅的创建对象

一 前言

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);
        }
    }
}

客户端使用这个对象的代码如下：

/**
 * 使用 Person04 对象的客户端
 */
public class Client04 {
    public static void main(String[] args) {
        /**
         * 通过链式调用的方式创建Person对象，非常优雅！
         */
        Person04 person04 = new Person04
                .Builder("xiaoliu",25)
                .setHeight(175)
                .setSchool("北京大学")
                .setHobby("reading")
                .build();
        person04.doSomeThing();

    }
}

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创建对象的六种方法-权当记录一下

感谢前人的经验、分享和付出，让我们可以有机会站在巨人的肩膀上眺望星辰大海！