Java 创建对象的7种方式
package com.xu.es.document.entity;
import lombok.Data;
import java.io.Serializable;
/**
* @author itmei
* @date 2023/5/25 21:48
* @description: 学生类
* @title: Student
* @package com.xu.es.document.entity
*/
@Data
public class Student implements Cloneable, Serializable {
public Student() {
}
public Student(int age) {
this.age = age;
}
private String id;
private int age;
private String name;
@Override
public Student clone() {
try {
return (Student) super.clone();
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
1 使用new关键字
这是最常见的创建对象的方式。使用 new 关键字,调用对象的构造方法来创建一个新的实例。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) {
Student object = new Student(10);
System.out.println(JSONUtil.toJsonPrettyStr(object));
}
}
{
"age": 10
}
Process finished with exit code 0
2 使用Class类的newInstance()方法
Java中的每个类都有一个名为 Class 的类对象,可以使用它的 newInstance() 方法创建类的实例。这种方式要求类必须有一个无参的构造方法。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) throws Exception {
Student object = Student.class.getDeclaredConstructor().newInstance();
System.out.println(JSONUtil.toJsonPrettyStr(object));
}
}
{
"age": 0
}
Process finished with exit code 0
3 使用Constructor类的newInstance()方法
Java的反射机制允许在运行时动态地获取类的信息并操作类。通过 Class 类的 getConstructor() 和 newInstance() 方法可以创建对象。这种方式可以使用带参的构造方法。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) throws Exception {
Class<?> clazz = Student.class;
Student object = (Student) clazz.getDeclaredConstructor(int.class).newInstance(10);
System.out.println(JSONUtil.toJsonPrettyStr(object));
}
}
{
"age": 10
}
Process finished with exit code 0
4 使用clone()方法
需要实现Cloneable,对象拷贝是创建对象的一种方式,它通过复制一个已有对象的值来创建一个新的对象。被拷贝的类需要实现 Cloneable 接口,并重写 clone() 方法,浅clone()不会调用构造方法。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) {
Student object = new Student(10);
Student object1 = object.clone();
System.out.println(JSONUtil.toJsonPrettyStr(object1));
}
}
{
"age": 10
}
Process finished with exit code 0
5 反序列化
需要实现Serializable,反序列化是将对象从字节流(如文件、网络传输等)转换回内存中的对象的过程。在进行反序列化时,Java会使用特定的机制创建对象,并将字节流中的数据填充到对象中。
反序列化创建对象的原理如下:
类加载:在进行反序列化之前,Java需要加载类的定义。如果已加载的类与序列化数据中的类完全匹配,则直接使用已加载的类。否则,Java会尝试根据序列化数据中的类名去加载类定义。
对象实例化:一旦类定义加载完成,Java使用类的构造函数创建一个新的对象实例。通常情况下,会调用类的无参构造函数来创建对象。如果类中没有无参构造函数,或者无法访问无参构造函数(如私有构造函数),则可能会导致反序列化失败。
数据填充:在对象实例化后,Java将会将序列化数据中的字段值逐个填充到对象的对应字段中。这个过程会使用反射来访问对象的字段,并根据字段的类型和值进行填充。
如果是文件可以使用FileInputStream和ByteArrayOutputStream的原理一样。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) throws Exception {
Student object = new Student(10);
byte[] bytes = serialize(object);
Student object1 = (Student) deserialize(bytes);
System.out.println(JSONUtil.toJsonPrettyStr(object1));
}
private static byte[] serialize(Student object) throws Exception {
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
ObjectOutputStream oOut = new ObjectOutputStream(bOut);
oOut.writeObject(object);
return bOut.toByteArray();
}
private static Object deserialize(byte[] object) throws Exception {
ObjectInputStream oIn = new ObjectInputStream(new ByteArrayInputStream(object));
return oIn.readObject();
}
}
{
"age": 10
}
Process finished with exit code 0
6 使用MethodHandles
Java MethodHandles是Java 7中引入的一种新的反射机制,它提供了对方法、字段和构造函数的动态访问和调用。相比传统的反射API,MethodHandles在性能和安全性方面都有所提升。
MethodHandles的原理可以简要概括为以下几个步骤:
获取MethodHandle:首先,需要通过MethodHandles类的静态方法来获取MethodHandle对象。MethodHandle是一个对具体方法、字段或构造函数的引用。
绑定方法接收者:MethodHandle对象是一个对方法的引用,但它并不包含方法所属的对象实例。因此,在使用MethodHandle之前,需要通过bind方法将方法接收者(即调用方法的对象实例)绑定到MethodHandle上。
调用方法:一旦获取到绑定了方法接收者的MethodHandle对象,就可以使用它来调用相应的方法。MethodHandle提供了一系列invoke方法,用于根据方法的不同签名进行调用。
MethodHandles的工作原理是基于底层的字节码指令,它直接操作方法、字段和构造函数的字节码,而不是通过反射API间接地调用它们。这使得MethodHandles比传统的反射API更高效。
MethodHandles的性能优势主要体现在以下几个方面:
内联优化:MethodHandles在字节码级别上进行操作,可以进行更好的内联优化,减少方法调用的开销。
类型检查:MethodHandles在编译时进行类型检查,而不是在运行时。这使得类型错误能够在编译时被发现,而不是在运行时抛出异常。
访问权限检查:MethodHandles可以直接访问private方法、字段和构造函数,而不受访问权限的限制。
适应动态语言:MethodHandles支持对动态语言(如动态类型语言)的调用,使得与传统的反射API相比更加灵活。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) throws Throwable {
MethodHandle handle = MethodHandles.lookup().findConstructor(Student.class, MethodType.methodType(void.class, int.class));
Student student = (Student) handle.invoke(10);
System.out.println(JSONUtil.toJsonPrettyStr(student));
}
}
{
"age": 10
}
Process finished with exit code 0
7 使用 Unfase
在 Java 中,Unsafe 是一个类提供了一些底层操作的方法,允许我们直接操纵内存和执行一些不安全的操作。Unsafe 类提供了访问 Java 虚拟机底层操作的能力,包括直接操作内存、执行本地方法、加载类、分配实例等。
通过使用 Unsafe 类的方法之一,allocateInstance(Class cls),可以在不调用构造函数的情况下创建对象。这是一种比较底层的操作,它会绕过类的构造函数,直接在内存中分配对象的空间。
这个方法的实现原理如下:
首先,allocateInstance(Class cls) 方法会获取传入的类的类描述符(Class Descriptor),该描述符包含了类的结构信息。
然后,Unsafe 类会根据类的描述符在堆中分配一块内存空间,这块空间足够存储类的实例对象。
接下来,Unsafe 类会对这块内存空间进行初始化,将其中的数据初始化为默认值(对于基本类型,会初始化为 0 或者默认值,对于引用类型,会初始化为 null)。
最后,allocateInstance(Class cls) 方法会返回这个内存空间的引用作为结果,即创建了一个新的对象实例。
需要注意的是,使用 Unsafe 类创建对象是一种底层的操作,需要特别小心使用。因为它会绕过构造函数,可能导致对象处于不一致的状态,或者执行一些不安全的操作。这种方式一般用于某些特殊需求的场景,比如一些框架或库的底层实现。对于普通的应用开发,一般不需要使用 Unsafe 类创建对象。
package com.xu.es.document.entity;
import cn.hutool.json.JSONUtil;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
/**
* @author x
* @date 2023/5/25 21:38
* @description: Java 创建对象的方式
* @title: Test
* @package com.xu.es.document.entity
*/
public class Test {
public static void main(String[] args) throws Throwable {
Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) unsafeField.get(null);
Student student = (Student) unsafe.allocateInstance(Student.class);
System.out.println(JSONUtil.toJsonPrettyStr(student));
}
}