QJniObject 类

成员函数文档

返回由 QJniObject 持有的对象，要么作为 jobject，要么作为类型 T。T 可以是JNI 对象类型之一。

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

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。

[显式] QJniObject::QJniObject(const char *className)

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

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

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

通过调用具有指定后续任何参数类型的签名 signature 的构造函数来创建一个新的JNI对象。

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

[显式，自6.4起] 模板 <typename... Args> QJniObject::QJniObject(const char *className, Args &&... args)

通过调用构造函数来创建一个新的JNI对象，该构造函数使用参数 args。此构造函数仅在所有 args 都已知的情况下可用。

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

此函数是在Qt 6.4中引入的。

[显式] QJniObject::QJniObject(jclass clazz)

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

[显式] 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);

[显式，自6.4起] 模板 <typename... Args> QJniObject::QJniObject(jclass clazz, Args &&... args)

通过调用具有参数 args 的构造函数来从 clazz 创建一个新的JNI对象。此构造函数仅在所有 args 都已知的情况下可用。

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

此函数是在Qt 6.4中引入的。

QJniObject::QJniObject(jobject object)

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

另请参阅：fromLocalRef().

[noexcept] QJniObject::~QJniObject()

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

[自6.4起] 模板 <typename Ret, typename... Args> auto QJniObject::callMethod(const char *methodName, const char *signature, Args &&... args) const

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

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

此函数是在Qt 6.4中引入的。

[自6.4起] 模板 <typename Ret, typename... Args> auto QJniObject::callMethod(const char *methodName, Args &&... args) const

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

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

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

此函数是在Qt 6.4中引入的。

[自6.4起] 模板 <typename Ret, typename... Args> QJniObject QJniObject::callObjectMethod(const char *methodName, Args &&... args) const

调用 Java 对象的方法 methodName 并带参数 args，返回一个新的 QJniObject 来表示返回的 Java 对象。

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

使用 signature 指定后续任何参数的类型，调用 Java 对象的方法 methodName。

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

[静态，自6.4起] 模板 <typename Ret, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&... args)

通过类 className 调用静态方法 methodName，使用 signature 指定后续任何参数的类型，返回方法的结果（除非 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中引入的。

[静态] 模板 <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);

[静态，自6.4起] 模板 <typename Ret, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, jmethodID methodId, Args &&... args)

调用指定为 methodId 的类 clazz 的静态方法以及任何后续参数，并返回类型为 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] 模板 <typename Ret, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, Args &&... args)

调用类 className 上的静态方法 methodName，使用参数 args，并返回类型为 Ret 的值（除非 Ret 是 void）。如果 Ret 是 jobject 类型，则返回值将是一个 QJniObject。

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

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

此函数是在Qt 6.4中引入的。

[static, since 6.4] 模板 <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.7] 模板 <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 需要是一个具有注册类型映射到 Java 类型的 C++ 类型。

此函数在 Qt 6.7 中引入。

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

使用 signature 指定后续任何参数的类型，从类 className 调用静态方法 methodName。

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, ...)

使用 signature 指定后续任何参数的类型，从类 clazz 调用静态方法 methodName。

[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, since 6.4] 模板 <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中引入的。

[静态，自 6.4 版起] 模板 <typename Ret, typename... Args> QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName, Args &&... args)

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

此函数是在Qt 6.4中引入的。

[自 6.2 版起] QByteArray QJniObject::className() const

以 QByteArray 的形式返回 QJniObject 所持有的类对象的名称。

此功能是在 Qt 6.2 中引入的。

[静态，自 6.4 版起] 模板 <typename Class, typename... Args> QJniObject QJniObject::construct(Args &&... args)

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

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

仅在所有 args 都是已知的 JNI 类型 时此函数可用。

此函数是在Qt 6.4中引入的。

[静态] QJniObject QJniObject::fromLocalRef(jobject localRef)

从一个本地 JNI 引用 localRef 创建一个 QJniObject。此函数在返回之前将占用 localRef 并释放它。

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

[静态] QJniObject QJniObject::fromString(const QString &string)

从 QString string 创建 Java 字符串并返回一个持有该字符串的 QJniObject。

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

另请参阅：toString()。

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

检索字段的值。

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

模板 <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;");

[静态] 模板 <typename T> auto QJniObject::getStaticField(const char *className, const char *fieldName)

从类 className 的静态字段 fieldName 中检索值。

[静态] 模板 <typename T> auto QJniObject::getStaticField (jclass clazz, const char *fieldName)

从 clazz 上的静态字段 fieldName 检索值。

[静态] 模板 <typename Klass, typename T> auto QJniObject::getStaticField (const char *fieldName)

从类 Klass 的静态字段 fieldName 中检索值。

Klass 需要是一个具有对 Java 类型进行映射的注册 C++ 类型。

[静态] 模板 <typename T> QJniObject::getStaticObjectField (const char *className, const char *fieldName)

从类 className 的字段 fieldName 检索对象。

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

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

从类 className 的字段 fieldName 和签名 signature 中检索 JNI 对象。

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

[静态] 模板 <typename T> QJniObject::getStaticObjectField (jclass clazz, const char *fieldName)

从 clazz 的字段 fieldName 检索对象。

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

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

从类 clazz 的字段 fieldName 和签名 signature 中检索 JNI 对象。

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

[静态] 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

[自 6.2 版起] jclass QJniObject::objectClass () const

以 jclass 形式返回 QJniObject 保持的类对象。

此功能是在 Qt 6.2 中引入的。

模板 <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);