Back to Qt.io
Contact Us Blog Download Qt

QJniObject Class

Java 本地接口 (JNI) 的便捷封装。更多

头文件： #include <QJniObject>
CMake： find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake： QT += core
自Qt 6.1

公共函数

QJniObject()
QJniObject(const char *className)
QJniObject(jclass clazz)
QJniObject(jobject object)
(since 6.4) QJniObject(const char *className, Args &&... args)
(since 6.4) QJniObject(jclass clazz, Args &&... args)
QJniObject(const char *className, const char *signature, ...)
QJniObject(jclass clazz, const char *signature, ...)
~QJniObject()
(since 6.4) auto callMethod(const char *methodName, Args &&... args) const
(since 6.4) auto callMethod(const char *methodName, const char *signature, Args &&... args) const
(since 6.4) QJniObject callObjectMethod(const char *methodName, Args &&... args) const
QJniObject callObjectMethod(const char *methodName, const char *signature, ...) const
(since 6.2) QByteArray className() const
auto getField(const char *fieldName) const
QJniObject getObjectField(const char *fieldName) const
QJniObject getObjectField(const char *fieldName, const char *signature) const
bool isValid() const
jobject object() const
T object() const
(since 6.2) jclass objectClass() const
void setField(const char *fieldName, T value)
void setField(const char *fieldName, const char *signature, T value)
(since 6.8) void swap(QJniObject &other)
QString toString() const
QJniObject &operator=(T object)

静态公共成员

(since 6.7) auto callStaticMethod(const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(const char *className, const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(jclass clazz, const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(jclass clazz, jmethodID methodId, Args &&... args)
(since 6.4) auto callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&... args)
auto callStaticMethod(jclass clazz, const char *methodName, const char *signature, Args &&... args)
(since 6.4) QJniObject callStaticObjectMethod(const char *className, const char *methodName, Args &&... args)
(since 6.4) QJniObject callStaticObjectMethod(jclass clazz, const char *methodName, Args &&... args)
QJniObject callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)
QJniObject callStaticObjectMethod(const char *className, const char *methodName, const char *signature, ...)
QJniObject callStaticObjectMethod(jclass clazz, const char *methodName, const char *signature, ...)
(since 6.4) QJniObject construct(Args &&... args)
QJniObject fromLocalRef(jobject localRef)
QJniObject fromString(const QString &string)
auto getStaticField(const char *fieldName)
auto getStaticField(const char *className, const char *fieldName)
auto getStaticField(jclass clazz, const char *fieldName)
QJniObject getStaticObjectField(const char *className, const char *fieldName)
QJniObject getStaticObjectField(jclass clazz, const char *fieldName)
QJniObject getStaticObjectField(const char *className, const char *fieldName, const char *signature)
QJniObject getStaticObjectField(jclass clazz, const char *fieldName, const char *signature)
bool isClassAvailable(const char *className)
auto setStaticField(const char *fieldName, T value)
void setStaticField(const char *className, const char *fieldName, T value)
void setStaticField(jclass clazz, const char *fieldName, T value)
void setStaticField(const char *className, const char *fieldName, const char *signature, T value)
void setStaticField(jclass clazz, const char *fieldName, const char *signature, T value)
bool operator!=(const QJniObject &o1, const QJniObject &o2)
bool operator==(const QJniObject &o1, const QJniObject &o2)

详细说明

QJniObject 类封装了对 Java 对象的引用，确保它不会被垃圾收集，并提供对大多数JNIEnv 方法调用（member、static）和字段（setter、getter）的访问。通过直接访问 JNI，包括异常处理在内的每项操作都省去了许多通常需要的模板。

注意： 此 API 是为在 Android 平台上使用而设计和测试的。尚未针对其他平台进行测试。

方法签名

QJniObject 提供了方便的函数，这些函数将根据所提供或推导出的模板参数使用正确的签名。

jint x = QJniObject::callMethod<jint>("getSize");
QJniObject::callMethod<void>("touch");
jint ret = jString1.callMethod<jint>("compareToIgnoreCase", jString2.object<jstring>());

这些函数是可变模板，编译器将从实际参数类型推导出签名。只有返回类型需要明确提供。QJniObject 可以为使用JNI types 的函数和使用QtJniTypes 类型映射声明的类型推导出签名字符串。

// Java class
package org.qtproject.qt;
class TestClass
{
    static TestClass create() { ... }
    static String fromNumber(int x) { ... }
    static String[] stringArray(String s1, String s2) { ... }
}
// C++ code
Q_DECLARE_JNI_CLASS(TestClass, "org/qtproject/qt/TestClass")

// ...
using namespace QtJniTypes;
TestClass testClass = TestClass::callStaticMethod<TestClass>("create");

这就允许在 C++ 代码中使用任意 Java 和 Android 类型，而无需明确创建 JNI 签名字符串。

显式 JNI 签名

您可以自己提供签名。在这种情况下，签名必须与要调用的函数相匹配。

  • 类名需要完全限定，例如："java/lang/String" 。
  • 方法签名的写法是"(ArgumentsTypes)ReturnType" ，请参见JNI Types 。
  • 所有对象类型都以 QJniObject 的形式返回。

下面的示例演示了如何调用不同的静态函数：

签名结构为"(ArgumentsTypes)ReturnType" 。签名中的数组类型必须有[ 前缀，完全限定的Object 类型名称必须有L 前缀和; 后缀。create 函数的签名是"()Lorg/qtproject/qt/TestClass; 。第二个和第三个函数的签名分别为"(I)Ljava/lang/String;" 和"(Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;" 。

我们可以这样调用create() 函数：

// C++ code
QJniObject testClass = QJniObject::callStaticObjectMethod("org/qtproject/qt/TestClass",
                                                          "create",
                                                          "()Lorg/qtproject/qt/TestClass;");

对于第二个和第三个函数，我们可以依靠 QJniObject 的模板方法创建隐式签名字符串，但也可以显式传递签名字符串：

// C++ code
QJniObject stringNumber = QJniObject::callStaticObjectMethod("org/qtproject/qt/TestClass",
                                                             "fromNumber",
                                                             "(I)Ljava/lang/String;", 10);

要使隐式签名创建有效，我们需要明确指定返回类型：

// C++ code
QJniObject string1 = QJniObject::fromString("String1");
QJniObject string2 = QJniObject::fromString("String2");
QJniObject stringArray = QJniObject::callStaticObjectMethod<jobjectArray>(
                                                            "org/qtproject/qt/TestClass",
                                                            "stringArray",
                                                            string1.object<jstring>(),
                                                            string2.object<jstring>());

请注意，虽然第一个模板参数指定了 Java 函数的返回类型，但该方法仍将返回一个 QJniObject。

处理 Java 异常

在调用可能抛出异常的 Java 函数后，重要的是在继续之前检查、处理和清除任何异常。所有 QJniObject 函数都通过报告和清除异常来在内部处理异常，从而使客户代码无需处理异常。

注意： 在直接使用JNIEnv 进行 JNI 调用时，用户必须手动处理异常。在异常挂起时进行其他 JNI 调用是不安全的。更多信息，请参阅QJniEnvironment::checkAndClearExceptions() 。

Java 本地方法

Java 本地方法使从 Java 调用本地代码成为可能，具体方法是在 Java 中创建一个函数声明，并在声明前加上native 关键字。在 Java 中调用本地函数之前，需要将 Java 本地函数映射到代码中的本地函数。映射函数可以通过调用QJniEnvironment::registerNativeMethods() 来完成。

下面的示例演示了如何进行映射。

Java 实现：

class FooJavaClass
{
    public static void foo(int x)
    {
        if (x < 100)
            callNativeOne(x);
        else
            callNativeTwo(x);
    }

private static native void callNativeOne(int x);
private static native void callNativeTwo(int x);

}

C++ 实现：

static voidfromJavaOne(JNIEnv*env,jobject thiz,jint x){
    Q_UNUSED(env);
    Q_UNUSED(thiz);
    qDebug() << x << "< 100";
}static voidfromJavaTwo(JNIEnv*env,jobject thiz,jint x){
    Q_UNUSED(env);
    Q_UNUSED(thiz);
    qDebug() << x << ">= 100";
}voidfoo() {// 先注册本地方法，最好在应用程序启动时完成 constJNINativeMethod methods[] ={{"callNativeOne", "(I)V", reinterpret_cast<void *>(fromJavaOne)},{"callNativeTwo", "(I)V", reinterpret_cast<void *>(fromJavaTwo)}}；    QJniEnvironmentenv;env.registerNativeMethods("my/java/project/FooJavaClass",methods, 2);//调用 java 方法，该方法将调用回 C++ 函数   QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo", "(I)V", 10);// 输出：10 < 100  QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo ", "(I)V", 100);// Output：100 >= 100}

Java 对象的生命周期

从 Java 接收到的大多数objects 都是本地引用，只有在从本地方法返回之前才有效。在此之后，该对象将被垃圾回收。如果您的代码在一个循环中创建了很多局部引用，您应该在每次迭代时手动删除它们，否则可能会耗尽内存。更多信息，请参阅JNI 设计概述：全局引用和局部引用。在本地方法作用域之外创建的局部引用必须手动删除，因为垃圾回收器不会自动释放它们，因为我们使用的是AttachCurrentThread。更多信息，请参阅JNI 技巧：本地引用和全局引用。

如果您想保持 Java 对象的生命周期，您需要为该对象创建一个新的全局引用并在完成后释放它，或者构建一个新的 QJniObject 并让它来管理 Java 对象的生命周期。

注意： QJniObject 只管理它自己的引用，如果您从全局或局部引用构建 QJniObject，QJniObject 将不会释放该引用。

JNI 类型

对象类型

类型签名
工作对象Ljava/lang/Object；
jclassLjava/lang/Class；
jstringLjava/lang/String；
jthrowableLjava/lang/Throwable；
工作项目数组[Ljava/lang/Object；
jarray[<type
jbooleanArray[Z
jbyteArray[B
jcharArray[C
短数组[S
jintArray[I
j 长数组[J
jfloatArray[F
jdoubleArray[D

原始类型

类型签名
j 布尔型Z
jbyteB
jcharC
jshortS
jintI
j 长J
jfloatF
jdoubleD

其他

类型签名
无效V
自定义类型L<fully-qualified-name>；

有关 JNI 的更多信息，请参阅《Java 本地接口规范》。

另请参阅 QJniEnvironment 和object()。

成员函数文档

template <typename T> T QJniObject::object() const

jobject QJniObject::object() const

以 jobject 或 T 类型返回QJniObject 持有的对象。T 可以是JNI Object Types 中的一个。

QJniObject string = QJniObject::fromString("Hello, JNI");
jstring jstring = string.object<jstring>();

注： 返回的对象仍由QJniObject 保存。要使对象在此QJniObject 的生命周期结束后仍然有效，例如记录下来以供日后使用，最简单的方法是将其存储在另一个具有适当生命周期的QJniObject 中。另外，也可以为对象创建一个新的全局引用并将其存储起来，同时注意在使用完毕后将其释放。

void functionScope()
{
    QString helloString("Hello");
    jstring myJString = 0;
    {
        QJniObject string = QJniObject::fromString(helloString);
        myJString = string.object<jstring>();
    }

   // Ops! myJString is no longer valid.
}

QJniObject::QJniObject()

构造一个无效的 JNI 对象。

另请参阅 isValid().

[explicit] QJniObject::QJniObject(const char *className)

调用className 的默认构造函数，构造一个新的 JNI 对象。

QJniObject myJavaString("java/lang/String");

[explicit] QJniObject::QJniObject(jclass clazz)

通过调用clazz 的默认构造函数来构造一个新的 JNI 对象。

注意： QJniObject 将为类创建一个新引用clazz ，并在销毁时再次释放该引用。在 QJniObject 外部创建的类引用需要由调用者管理。

QJniObject::QJniObject(jobject object)

围绕 Java 对象object 构建一个新的 JNI 对象。

注意： QJniObject 将持有对 Java 对象object 的引用，并在销毁时释放该引用。QJniObject 外部对 Java 对象object 的任何引用都需要由调用者管理。在大多数情况下，除非您打算自己管理本地引用，否则绝不应使用本地引用调用此函数。请参阅QJniObject::fromLocalRef() 将本地引用转换为 QJniObject。

另请参见 fromLocalRef()。

[explicit, since 6.4] template <typename... Args> QJniObject::QJniObject(const char *className, Args &&... args)

使用参数args 调用className 的构造函数，构造一个新的 JNI 对象。只有当所有args 都已知时，该构造函数才可用JNI Types 。

QJniEnvironment env;
char* str = "Hello";
jstring myJStringArg = env->NewStringUTF(str);
QJniObject myNewJavaString("java/lang/String", myJStringArg);

该函数在 Qt 6.4 中引入。

[explicit, since 6.4] template <typename... Args> QJniObject::QJniObject(jclass clazz, Args &&... args)

通过调用带有参数的构造函数args ，从clazz 构造一个新的 JNI 对象。只有当所有args 都已知时，该构造函数才可用JNI Types 。

QJniEnvironment env;
jclass myClazz = env.findClass("org/qtproject/qt/TestClass");
QJniObject(myClazz, 3);

该函数在 Qt 6.4 中引入。

[explicit] QJniObject::QJniObject(const char *className, const char *signature, ...)

通过调用className 的构造函数构造一个新的 JNI 对象，其中signature 指定了后续参数的类型。

QJniEnvironment env;
char* str = "Hello";
jstring myJStringArg = env->NewStringUTF(str);
QJniObject myNewJavaString("java/lang/String", "(Ljava/lang/String;)V", myJStringArg);

[explicit] QJniObject::QJniObject(jclass clazz, const char *signature, ...)

通过调用构造函数signature ，指定后续参数的类型，从clazz 构造一个新的 JNI 对象。

QJniEnvironment env;
jclass myClazz = env.findClass("org/qtproject/qt/TestClass");
QJniObject(myClazz, "(I)V", 3);

[noexcept] QJniObject::~QJniObject()

销毁 JNI 对象，并释放 JNI 对象持有的任何引用。

[since 6.4] template <typename Ret, typename... Args> auto QJniObject::callMethod(const char *methodName, Args &&... args) const

调用带有参数args 的方法methodName 并返回值（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

QJniObject myJavaString("org/qtproject/qt/TestClass");
jint size = myJavaString.callMethod<jint>("length");

方法签名是在编译时根据Ret 和args 的类型推导出来的。

该函数在 Qt 6.4 中引入。

[since 6.4] template <typename Ret, typename... Args> auto QJniObject::callMethod(const char *methodName, const char *signature, Args &&... args) const

调用对象的方法methodName ，其中signature 指定任何后续参数的类型args ，并返回值（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

QJniObject myJavaString("org/qtproject/qt/TestClass");
jint index = myJavaString.callMethod<jint>("indexOf", "(I)I", 0x0051);

该函数在 Qt 6.4 中引入。

[since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callObjectMethod(const char *methodName, Args &&... args) const

使用参数args 调用 Java 对象方法methodName ，并为返回的 Java 对象返回一个新的QJniObject 。

QJniObject myJavaString = QJniObject::fromString("Hello, Java");
QJniObject myJavaString2 = myJavaString1.callObjectMethod<jstring>("toString");

方法签名是在编译时根据Ret 和args 的类型推导出来的。

该函数在 Qt 6.4 中引入。

QJniObject QJniObject::callObjectMethod(const char *methodName, const char *signature, ...) const

调用 Java 对象的方法methodName ，其中signature 指定了后续参数的类型。

QJniObject myJavaString = QJniObject::fromString("Hello, Java");
QJniObject mySubstring = myJavaString.callObjectMethod("substring",
                                                       "(II)Ljava/lang/String;", 7, 11);

[static, since 6.7] template <typename Klass, typename Ret, typename... Args> auto QJniObject::callStaticMethod(const char *methodName, Args &&... args)

调用类Klass 上的静态方法methodName ，并返回Ret 类型的值（除非Ret 是void ）。如果Ret 是 jobject 类型，那么返回值将是QJniObject 。

方法签名是在编译时从Ret 和args 的类型中推导出来的。Klass 需要是一个 C++ 类型，并注册了与 Java 类型的类型映射。

该函数在 Qt 6.7 中引入。

[static, since 6.4] template <typename Ret, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, Args &&... args)

调用带有参数args 的类className 上的静态方法methodName ，并返回Ret 类型的值（除非Ret 是void ）。如果Ret 是 jobject 类型，那么返回值将是QJniObject 。

jint value = QJniObject::callStaticMethod<jint>("MyClass", "staticMethod");

方法签名是在编译时根据Ret 和args 的类型推导出来的。

该函数在 Qt 6.4 中引入。

[static, since 6.4] template <typename Ret, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, const char *methodName, Args &&... args)

调用clazz 上的静态方法methodName ，并返回Ret 类型的值（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jdouble randNr = QJniObject::callStaticMethod<jdouble>(javaMathClass, "random");

方法签名是在编译时根据Ret 和args 的类型推导出来的。

该函数在 Qt 6.4 中引入。

[static, since 6.4] template <typename Ret, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, jmethodID methodId, Args &&... args)

调用类clazz 中methodId 所标识的静态方法及随后的参数，并返回Ret 类型的值（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

当之前的操作已缓存了clazz 和methodId 时，该函数将非常有用。

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jmethodID methodId = env.findStaticMethod(javaMathClass, "max", "(II)I");
if (methodId != 0) {
    jint a = 2;
    jint b = 4;
    jint max = QJniObject::callStaticMethod<jint>(javaMathClass, methodId, a, b);
}

此函数在 Qt 6.4 中引入。

[static, since 6.4] template <typename Ret, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&... args)

调用类className 中的静态方法methodName ，同时signature 指定任何后续参数的类型args 。返回方法的结果（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

jint a = 2;
jint b = 4;
jint max = QJniObject::callStaticMethod<jint>("java/lang/Math", "max", "(II)I", a, b);

此函数在 Qt 6.4 中引入。

[static] template <typename Ret, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, const char *methodName, const char *signature, Args &&... args)

调用来自clazz 的静态方法methodName ，其中signature 指定了后续参数的类型。返回方法的结果（除非Ret 是void ）。如果Ret 是 jobject 类型，则返回值将是QJniObject 。

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jint a = 2;
jint b = 4;
jint max = QJniObject::callStaticMethod<jint>(javaMathClass, "max", "(II)I", a, b);

[static, since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName, Args &&... args)

在类className 上调用静态方法methodName ，传递参数args ，并返回一个新的QJniObject 作为返回的 Java 对象。

QJniObject string = QJniObject::callStaticObjectMethod<jstring>("CustomClass", "getClassName");

方法签名是在编译时根据Ret 和args 的类型推导出来的。

该函数在 Qt 6.4 中引入。

[static, since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName, Args &&... args)

在clazz 上调用静态方法methodName ，传递参数args ，并为返回的 Java 对象返回一个新的QJniObject 。

该函数在 Qt 6.4 中引入。

[static] QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)

调用类clazz 中methodId 标识的静态方法及任何后续参数。当clazz 和methodId 已从以前的操作中缓存时，这种方法就很有用。

QJniEnvironment env;
jclass clazz = env.findClass("java/lang/String");
jmethodID methodId = env.findStaticMethod(clazz, "valueOf", "(I)Ljava/lang/String;");
if (methodId != 0)
    QJniObject str = QJniObject::callStaticObjectMethod(clazz, methodId, 10);

[static] QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName, const char *signature, ...)

调用className 类中的静态方法methodName ，其中signature 指定了后续参数的类型。

QJniObject thread = QJniObject::callStaticObjectMethod("java/lang/Thread", "currentThread",
                                                       "()Ljava/lang/Thread;");
QJniObject string = QJniObject::callStaticObjectMethod("java/lang/String", "valueOf",
                                                       "(I)Ljava/lang/String;", 10);

[static] QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName, const char *signature, ...)

调用clazz 类中的静态方法methodName ，其中signature 指定了后续参数的类型。

[since 6.2] QByteArray QJniObject::className() const

返回由QJniObject 持有的类对象的名称（QByteArray ）。

该函数在 Qt 6.2 中引入。

[static, since 6.4] template <typename Class, typename... Args> QJniObject QJniObject::construct(Args &&... args)

构造一个与Class 等价的 Java 类实例，并返回一个包含 JNI 对象的QJniObject 。args 中的参数传递给 Java 构造函数。

QJniObject javaString = QJniObject::construct<jstring>();

只有当所有args 都是已知的JNI Types 时，该函数才可用。

该函数在 Qt 6.4 中引入。

[static] QJniObject QJniObject::fromLocalRef(jobject localRef)

从本地 JNI 引用localRef 创建QJniObject 。该函数获取localRef 的所有权，并在返回前释放它。

注意： 只能使用本地 JNI 引用调用此函数。例如，大多数原始 JNI 调用都是通过 JNI 环境返回 java 对象的本地引用。

jobject localRef = env->GetObjectArrayElement(array, index);
QJniObject element = QJniObject::fromLocalRef(localRef);

[static] QJniObject QJniObject::fromString(const QString &string)

从QString string 创建 Java 字符串，并返回包含该字符串的QJniObject 。

QString myQString = "QString";
QJniObject myJavaString = QJniObject::fromString(myQString);

另请参阅 toString().

template <typename T> auto QJniObject::getField(const char *fieldName) const

读取字段fieldName 的值。

QJniObject volumeControl("org/qtproject/qt/TestClass");
jint fieldValue = volumeControl.getField<jint>("FIELD_NAME");

template <typename T> QJniObject QJniObject::getObjectField(const char *fieldName) const

从字段fieldName 中读取一个 JNI 对象。

QJniObject field = jniObject.getObjectField<jstring>("FIELD_NAME");

QJniObject QJniObject::getObjectField(const char *fieldName, const char *signature) const

通过signature 从字段fieldName 中读取一个 JNI 对象。

注： 该函数可以在没有模板类型的情况下使用。

QJniObject field = jniObject.getObjectField("FIELD_NAME", "Ljava/lang/String;");

[static] template <typename Klass, typename T> auto QJniObject::getStaticField(const char *fieldName)

从静态字段fieldName 中读取Klass 类的值。

Klass 静态字段需要是一个 C++ 类型，并已注册为 Java 类型的映射。

[static] template <typename T> auto QJniObject::getStaticField(const char *className, const char *fieldName)

从类className 的静态字段fieldName 中读取值。

[static] template <typename T> auto QJniObject::getStaticField(jclass clazz, const char *fieldName)

从clazz 上的静态字段fieldName 读取值。

[static] template <typename T> QJniObject QJniObject::getStaticObjectField(const char *className, const char *fieldName)

从类className 的字段fieldName 中读取对象。

QJniObject jobj = QJniObject::getStaticObjectField<jstring>("class/with/Fields", "FIELD_NAME");

[static] template <typename T> QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName)

从clazz 上的字段fieldName 中读取对象。

QJniObject jobj = QJniObject::getStaticObjectField<jstring>(clazz, "FIELD_NAME");

[static] QJniObject QJniObject::getStaticObjectField(const char *className, const char *fieldName, const char *signature)

从字段fieldName 中读取一个 JNI 对象，字段为类className 中的signature 。

注： 该函数可以在没有模板类型的情况下使用。

QJniObject jobj = QJniObject::getStaticObjectField("class/with/Fields", "FIELD_NAME",
                                                   "Ljava/lang/String;");

[static] QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName, const char *signature)

从字段fieldName 中读取一个 JNI 对象，字段为类clazz 中的signature 。

注： 该函数可以在没有模板类型的情况下使用。

QJniObject jobj = QJniObject::getStaticObjectField(clazz, "FIELD_NAME", "Ljava/lang/String;");

[static] bool QJniObject::isClassAvailable(const char *className)

如果 Java 类className 可用，则返回 true。

if (QJniObject::isClassAvailable("java/lang/String")) {
    // condition statement
}

bool QJniObject::isValid() const

如果此实例持有有效的 Java 对象，则返回 true。

QJniObject qjniObject;                        // ==> isValid() == false
QJniObject qjniObject(0)                      // ==> isValid() == false
QJniObject qjniObject("could/not/find/Class") // ==> isValid() == false

[since 6.2] jclass QJniObject::objectClass() const

返回由QJniObject 作为jclass 持有的类对象。

注： 返回的对象仍由QJniObject 保存。要使对象在此QJniObject 的生命周期结束后仍然有效，例如记录下来以备日后使用，最简单的方法是将其存储在另一个具有适当生命周期的QJniObject 中。或者，您也可以为对象创建一个新的全局引用并将其存储起来，同时注意在使用完毕后释放它。

此函数在 Qt 6.2 中引入。

template <typename T> void QJniObject::setField(const char *fieldName, T value)

将fieldName 的值设置为value 。

QJniObject obj;
obj.setField<jint>("AN_INT_FIELD", 10);
jstring myString = ...;
obj.setField<jstring>("A_STRING_FIELD", myString);

template <typename T> void QJniObject::setField(const char *fieldName, const char *signature, T value)

将fieldName 的值与signature 设置为value 。

QJniObject stringArray = ...;
QJniObject obj = ...;
obj.setObjectField<jobjectArray>("KEY_VALUES", "([Ljava/lang/String;)V",
                           stringArray.object<jobjectArray>())

[static] template <typename Klass, typename T> auto QJniObject::setStaticField(const char *fieldName, T value)

将类Klass 的静态字段fieldName 设置为value 。

Klass 静态字段需要是一个 C++ 类型，并已注册为 Java 类型的映射。

[static] template <typename T> void QJniObject::setStaticField(const char *className, const char *fieldName, T value)

将类className 的静态字段fieldName 设置为value 。

[static] template <typename T> void QJniObject::setStaticField(jclass clazz, const char *fieldName, T value)

将类clazz 的静态字段fieldName 设置为value 。

[static] template <typename T> void QJniObject::setStaticField(const char *className, const char *fieldName, const char *signature, T value)

使用signature 的设置器将类className 上的静态字段fieldName 设置为value 。

[static] template <typename T> void QJniObject::setStaticField(jclass clazz, const char *fieldName, const char *signature, T value)

使用signature 的设置器将类clazz 上的静态字段fieldName 设置为value 。

[noexcept, since 6.8] void QJniObject::swap(QJniObject &other)

将此对象与other 互换。该操作速度非常快，而且不会失败。

此函数在 Qt 6.8 中引入。

QString QJniObject::toString() const

返回包含 Java 对象字符串表示的QString 。在 Java 字符串对象上调用此函数可以方便地获取实际字符串数据。

QJniObject string = ...; //  "Hello Java"
QString qstring = string.toString(); // "Hello Java"

另请参阅 fromString()。

template <typename T, std::enable_if_t<std::is_convertible_v<T, jobject>, bool> = true> QJniObject &QJniObject::operator=(T object)

用object 替换当前对象。旧的 Java 对象将被释放。

相关非会员

bool operator!=(const QJniObject &o1, const QJniObject &o2)

如果o1 持有与o2 不同的对象引用，则返回 true。

bool operator==(const QJniObject &o1, const QJniObject &o2)

如果o1 和o2 这两个对象引用的是同一个 Java 对象，或者这两个对象都为 NULL，则返回 true。否则将返回 false。

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.