使用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());
}
}