建议结合上一篇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、子类构造函数