Original address: http://geek.csdn.net/news/detail/187272?ref=myread

As Java developers, we create many objects every day, but we usually use dependency management systems, such as Spring, to create objects. However, there are many ways to create objects, which we will learn in this article.

There are five ways to create objects in Java. Here are their examples and their bytecodes.

If you run the program at the end, you will find that method 1, 2, 3 creates objects with constructors, and method 4, 5 does not call constructors.

1. Use new keywords

This is the most common and easiest way to create objects. In this way, we can call any constructor (parametric and parametric).

Employee emp1 = new Employee();

0: new           #19          // class org/programming/mitra/exercises/Employee
3: dup
4: invokespecial #21          // Method org/programming/mitra/exercises/Employee."":()V

2. New Instance Method Using Class Class Class

We can also create objects using the newInstance method of the Class class. This newInstance method calls an argument-free constructor to create an object.

We can create objects by calling the newInstance method in the following way:

Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee").newInstance();

perhaps

Employee emp2 = Employee.class.newInstance();

51: invokevirtual    #70    // Method java/lang/Class.newInstance:()Ljava/lang/Object;

3. New Instance Method Using Constructor Class

Similar to the newInstance method of the Classes Class, there is also a newInstance method in the java.lang.reflect.Constructor Class to create objects. We can call parameterized and private constructors through this newInstance method.

Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();

111: invokevirtual  #80  // Method java/lang/reflect/Constructor.newInstance:([Ljava/lang/Object;)Ljava/lang/Object;

These two new Instance methods are what we call reflection. In fact, Class's newInstance method calls Constructor's newInstance method internally. This is why many frameworks, such as Spring, Hibernate, Struts, use the latter. To understand the difference between these two new Instance methods, see this article Creating objects through Reflection in Java with Example.

4. Using clone method

Whenever we call the clone method of an object, the jvm creates a new object and copies all the contents of the previous object. Creating objects with the clone method does not call any constructors.

To use the clone method, we need to implement the Cloneable interface and implement the clone method defined by it.

Employee emp4 = (Employee) emp3.clone();

162: invokevirtual #87  // Method org/programming/mitra/exercises/Employee.clone ()Ljava/lang/Object;

5. Use deserialization

When we serialize and deserialize an object, the jvm creates a separate object for us. When deserializing, the jvm creates objects without calling any constructors.  
To deserialize an object, we need to have our class implement the Serializable interface

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();

261: invokevirtual  #118   // Method java/io/ObjectInputStream.readObject:()Ljava/lang/Object;

As we can see from the bytecode fragment above, except for the first method, all four other methods have been transformed into invokevirtual (the direct method for creating objects), and the first method has been transformed into two calls, new and invokespecial (constructor calls).

Example

Let's look at creating objects for the Employee class below:

class Employee implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    public Employee() {
        System.out.println("Employee Constructor Called...");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Employee [name=" + name + "]";
    }
    @Override
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

In the following Java program, we will create Employee objects in five ways. You can find the code from GitHub.

public class ObjectCreation {
    public static void main(String... args) throws Exception {
        // By using new keyword
        Employee emp1 = new Employee();
        emp1.setName("Naresh");
        System.out.println(emp1 + ", hashcode : " + emp1.hashCode());
        // By using Class class's newInstance() method
        Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")
                               .newInstance();
        // Or we can simply do this
        // Employee emp2 = Employee.class.newInstance();
        emp2.setName("Rishi");
        System.out.println(emp2 + ", hashcode : " + emp2.hashCode());
        // By using Constructor class's newInstance() method
        Constructor<Employee> constructor = Employee.class.getConstructor();
        Employee emp3 = constructor.newInstance();
        emp3.setName("Yogesh");
        System.out.println(emp3 + ", hashcode : " + emp3.hashCode());
        // By using clone() method
        Employee emp4 = (Employee) emp3.clone();
        emp4.setName("Atul");
        System.out.println(emp4 + ", hashcode : " + emp4.hashCode());
        // By using Deserialization
        // Serialization
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));
        out.writeObject(emp4);
        out.close();
        //Deserialization
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
        Employee emp5 = (Employee) in.readObject();
        in.close();
        emp5.setName("Akash");
        System.out.println(emp5 + ", hashcode : " + emp5.hashCode());
    }
}

The program will output:

Employee Constructor Called...
Employee [name=Naresh], hashcode : -1968815046
Employee Constructor Called...
Employee [name=Rishi], hashcode : 78970652
Employee Constructor Called...
Employee [name=Yogesh], hashcode : -1641292792
Employee [name=Atul], hashcode : 2051657
Employee [name=Akash], hashcode : 63313419