Java 创建对象的7种方式

本文介绍了Java中创建对象的七种不同方法,包括使用new关键字、Class.newInstance()、Constructor.newInstance()、对象的clone()方法、反序列化、MethodHandles以及Unsafe的allocateInstance()。每种方法都有其适用场景和特点,例如new关键字是最常见的构造方式,而Unsafe则提供底层内存操作,通常用于特殊需求。
摘要由CSDN通过智能技术生成

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

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值