Java对象的创建和初始化-原创手记-慕课网

建议结合上一篇Java类的加载和初始化一起阅读，将帮助你理解：

什么是Class，什么是class
Java虚拟机启动和类的加载过程
对象的创建方式和初始化顺序

对象的创建方式

下面结合代码介绍几种对象的创建方式：

 //待实例化的类public class Worker implements Cloneable,Serializable {    private static final long serialVersionUID = 1L;    private String name;    private Integer age;    public Worker()
    {        this.name = "";        this.age = 0;
    }    public Worker(String name,Integer 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) {
            e.printStackTrace();
        }        return worker;
    }
}

方式1：直接使用new的方式,不使用参数

    public static Worker createWorker() {
        System.out.println("直接使用new的方式,不使用参数");        return new Worker();
    }

方式2：使用new方式，带参数

    public static Worker createWorker(String name, int age) {
        System.out.println("使用new方式，带参数");        return new Worker(name, age);
    }

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

     public static Worker createWorker1() {

        Class clazz = null;
        Worker worker = null;        try {
            clazz = Class.forName("com.code.loader.Worker");
            worker = (Worker) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        System.out.println("使用反射机制，不带参数的newInstance()方法");        return worker;
    }

方式4：使用反射机制， Constructor的 newInstance方法

    public static Worker createWorker2() {
        Worker worker = null;        try {
            Class clazz = null;
            clazz = Class.forName("com.code.loader.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();
        }
        System.out.println("使用反射机制，Constructor的newInstance方法");        return worker;
    }

方式5：使用反射机制：带参数的构造函数创建新对象

   public static Worker createWorker3(String name, Integer age) {
        Worker worker = null;        try {
            Class clazz = null;
            clazz = Class.forName("com.code.loader.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();
        }
        System.out.println("使用反射机制，带参数的构造函数创建新对象");        return worker;
    }

方式6：使用序列化和反序列化创建对象

public static Worker createWorker4(String name, Integer age){
        Worker person = new Worker();
        person.setName(name);
        person.setAge(age);        //序列化
        OutputStream outputStream = new FileOutputStream("person.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(person);
        outputStream.close();
        objectOutputStream.close();        //反序列化
        InputStream inputStream = new FileInputStream("person.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);        return (Worker) objectInputStream.readObject();
}

方式7：使用对象的clone方法，创建对象

  public static Worker createWorker5(Worker worker) {
        System.out.println("使用对象的复制，创建对象");        return (Worker) worker.clone();
    }

对象的初始化顺序

结合代码，分析对象的初始化顺序

public class Test {    public static void main(String[] args) {
        Child child = new Child();
    }

}class Father {    public static String fatherStr1 = "fatherStr1（静态字段初始化值）";    public String fatherStr2 = "fatherStr2（字段初始化值）";    static {
        System.out.println("父类静态代码块：" + fatherStr1);
        fatherStr1 = "fatherStr1（静态代码块赋值）";
    }

    {
        System.out.println("父类构造代码块：" + fatherStr2);
        fatherStr2 = "fatherStr2（构造代码块赋值）";
    }    public Father() {
        System.out.println("父类构造函数块：" + fatherStr2);
        fatherStr2 = "fatherStr2（构造函数赋值）";
    }
}class Child extends Father {    public static String childStr1 = "childStr1（静态字段初始化值）";    public String childStr2 = "childStr2（字段初始化值）";    static {
        System.out.println("子类静态代码块：" + childStr1);
        childStr1 = "childStr1（静态代码块赋值）";
    }

    {
        System.out.println("子类构造代码块：" + childStr2);
        childStr2 = "childStr2（构造代码块赋值）";
    }    public Child() {
        System.out.println("子类构造函数：" + childStr2);
        childStr2 = "childStr2（构造函数赋值）";
    }
}     /*输出结果：
    父类静态代码块：fatherStr1（静态字段初始化值）
    子类静态代码块：childStr1（静态字段初始化值）
    父类构造代码块：fatherStr2（字段初始化值）
    父类构造函数块：fatherStr2（构造代码块赋值）
    子类构造代码块：childStr2（字段初始化值）
    子类构造函数：childStr2（构造代码块赋值）*/

总结如下，其中静态字段和静态代码块属于类的初始化过程
1、父类静态字段初始化，静态代码块初始化
2、子类静态字段初始化，子类静态代码块初始化
3、父类普通字段初始化，普通代码块初始化
4、父类构造函数
5、子类普通字段初始化，普通代码块初始化
6、子类构造函数

作者：匠丶
链接：https://www.jianshu.com/p/a4ff6b0a9661