Java 创建对象的7种方式

深色風信子

已于 2023-05-25 22:42:29 修改

阅读量2.8k

点赞数

文章标签： java jvm servlet

于 2023-05-25 22:40:27 首次发布

本文链接：https://blog.csdn.net/qq_34814092/article/details/130876170

版权

Java 创建对象的7种方式

1 使用new关键字
2 使用Class类的newInstance()方法
3 使用Constructor类的newInstance()方法
4 使用clone()方法
5 反序列化
6 使用MethodHandles
7 使用 Unfase

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));
    }

}