Java创建对象的5种方法

使用new关键字

       通过使用此方法，我们可以调用要调用的任何构造函数，即可以调用无参数的构造函数也可以调用有参数的构造函数。

       User user = new User();

       User user = new User(1,”admin”,19);

使用Class类的newInstance()方法

       例如：

       User user = Class.forName(“com.smile.entity.User”).newInstance();

       或者：

       User user = User.class.newInstance();

使用构造方法类的newInstance()方法

       与上面的使用Class类的newInstance()方法类似，java.lang.reflect.Constructor类中共有一个newInstance()方法可用于创建对象。

       Constructor<User> constructor = User.class.getConstructor();

       User user = constructor.newInstance();

       这里的newInstance方法和上面使用Class类的newInstance方法都被称为创建对象的反射方式。实际上Class类的newInstance()方法在内部使用了Constructor类的newInstance()方法，这就是为什么最好使用后一种方法。

使用clone()方法

       在任何对象上调用clone()时，JVM实际上都会为我们创建一个新对象，并将先前对象的所有内容复制到其中。使用clone()方法创建对象不会调用任何构造函数。

       要在对象上使用clone()方法，我们需要实现Cloneable，并在其中定义clone()方法。

使用反序列化

       每当我们序列化和反序列化一个对象的时候，JVM就会为我们创建一个单独的对象。在反序列化中，JVM不适用任何构造函数来创建对象。要反序列化对象，我们需要在类中实现Serializable接口。

示例

1、创建实体类

import java.io.Serializable;
import java.util.Objects;

public 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 boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Employee employee = (Employee) obj;
        return Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public String toString() {
        return String.format("Employee{name='%s'}", name);
    }

    @Override
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

2、对象创建

import com.one.smile.test.dto.Employee;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

public class ObjectCreation {

    public static void main(String[] args) throws Exception {

        //1、Using new keyword
        Employee employee1 = new Employee();
        employee1.setName("employee");

        //2、Using Class.newInstance() method
        Employee employee2 = Employee.class.newInstance();
        employee2.setName("employee2");

        //Using Constructor newInstance method
        Constructor<Employee> constructor = Employee.class.getConstructor();
        Employee employee3 = constructor.newInstance();
        employee3.setName("employee3");

        //4、Using clone method
        Employee employee4 = (Employee) employee3.clone();
        employee4.setName("employee4");

        //5、Serializable(序列化)
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"))) {
            out.writeObject(employee4);
        }

        //6、Using Deserailizable(反序列化)
        Employee employee5;
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"))) {
            employee5 = (Employee) in.readObject();
            employee5.setName("employee5");
        }

        System.out.println(employee1 + "hashCode:" + employee1.hashCode());
        System.out.println(employee2 + "hashCode:" + employee2.hashCode());
        System.out.println(employee3 + "hashCode:" + employee3.hashCode());
        System.out.println(employee4 + "hashCode:" + employee4.hashCode());
        System.out.println(employee5 + "hashCode:" + employee5.hashCode());

    }

}