diff --git a/src/corelib/kernel/qjniobject.cpp b/src/corelib/kernel/qjniobject.cpp
index 14a5f3ef7dc..6bfd4ac5968 100644
--- a/src/corelib/kernel/qjniobject.cpp
+++ b/src/corelib/kernel/qjniobject.cpp
@@ -1386,7 +1386,7 @@ bool QJniObject::isSameObject(const QJniObject &other) const
 
 void QJniObject::assign(jobject obj)
 {
-    if (isSameObject(obj))
+    if (d && isSameObject(obj))
         return;
 
     jobject jobj = static_cast<jobject>(obj);
diff --git a/src/corelib/kernel/qjniobject.h b/src/corelib/kernel/qjniobject.h
index 4b343709236..6fe646d50fb 100644
--- a/src/corelib/kernel/qjniobject.h
+++ b/src/corelib/kernel/qjniobject.h
@@ -42,6 +42,8 @@ class Q_CORE_EXPORT QJniObject
             using Type = q20::remove_cvref_t<T>;
             if constexpr (std::is_same_v<Type, QString>) {
                 return newLocalRef<jstring>(QJniObject::fromString(value));
+            } else if constexpr (std::is_base_of_v<QJniObject, Type>) {
+                return value.object();
             } else {
                 return static_cast<T &&>(value);
             }
@@ -52,8 +54,11 @@ class Q_CORE_EXPORT QJniObject
             using Type = q20::remove_cvref_t<T>;
             if constexpr (std::is_same_v<Type, QString>) {
                 return object.toString();
+            } else if constexpr (std::is_base_of_v<QJniObject, Type>
+                              && !std::is_same_v<QJniObject, Type>) {
+                return T{std::move(object)};
             } else {
-                return object;
+                return std::move(object);
             }
         }
     };
@@ -67,9 +72,12 @@ public:
 #endif
         >
     explicit QJniObject(const char *className, Args &&...args)
-        : QJniObject(className, QtJniTypes::constructorSignature<Args...>().data(),
-                     std::forward<Args>(args)...)
-    {}
+        : QJniObject(Qt::Uninitialized)
+    {
+        LocalFrame<Args...> localFrame;
+        *this = QJniObject(className, QtJniTypes::constructorSignature<Args...>().data(),
+                           localFrame.convertToJni(std::forward<Args>(args))...);
+    }
     explicit QJniObject(jclass clazz);
     explicit QJniObject(jclass clazz, const char *signature, ...);
     template<typename ...Args
@@ -82,6 +90,12 @@ public:
                      std::forward<Args>(args)...)
     {}
     QJniObject(jobject globalRef);
+
+    QJniObject(const QJniObject &other) noexcept = default;
+    QJniObject(QJniObject &&other) noexcept = default;
+    QJniObject &operator=(const QJniObject &other) noexcept = default;
+    QJniObject &operator=(QJniObject &&other) noexcept = default;
+
     ~QJniObject();
 
     template<typename Class, typename ...Args>
@@ -527,6 +541,9 @@ public:
         return *this;
     }
 
+protected:
+    QJniObject(Qt::Initialization) {}
+
 private:
     static jclass loadClass(const QByteArray &className, JNIEnv *env);
 
diff --git a/src/corelib/kernel/qjnitypes.h b/src/corelib/kernel/qjnitypes.h
index 6007dd32975..a3346ec3f43 100644
--- a/src/corelib/kernel/qjnitypes.h
+++ b/src/corelib/kernel/qjnitypes.h
@@ -13,25 +13,176 @@ QT_BEGIN_NAMESPACE
 
 namespace QtJniTypes
 {
-// A generic thin wrapper around jobject, convertible to jobject.
-// We need this as a baseclass so that QJniObject can be implicitly
-// constructed from the various subclasses. We can also pass instances
-// of this type (or of any of the generated subclasses) as if it was
-// a jobject.
-struct Object
+// A generic base class for specialized QJniObject types, to be used by
+// subclasses via CRTP. It's implicitly convertible to and from jobject, which
+// allows the QJniObject implementation to implicitly pass instances of this
+// type through the variadic argument JNI APIs.
+template<typename Type>
+struct Object : QJniObject
 {
-    jobject _object;
-    constexpr operator jobject() const { return _object; }
-    operator QJniObject() const { return QJniObject(_object); }
+    using Class = Type;
+    operator jobject() const noexcept { return object(); }
+
+    Q_IMPLICIT Object(jobject object) : QJniObject(object) {}
+    Q_IMPLICIT Object(const QJniObject &object) : QJniObject(object) {}
+    Q_IMPLICIT Object(QJniObject &&object) : QJniObject(std::move(object)) {}
+
+    // Compiler-generated copy/move semantics based on QJniObject's shared d-pointer are fine!
+    Object(const Object<Type> &other) = default;
+    Object(Object<Type> &&other) = default;
+    Object<Type> &operator=(const Object<Type> &other) = default;
+    Object<Type> &operator=(Object<Type> &&other) = default;
+
+    // avoid ambiguities with deleted const char * constructor
+    Q_IMPLICIT Object(std::nullptr_t) : QJniObject() {}
+
+    // this intentionally includes the default constructor
+    template<typename ...Args
+            , ValidSignatureTypes<Args...> = true
+    >
+    explicit Object(Args &&...args)
+        : QJniObject(Qt::Initialization::Uninitialized)
+    {
+        *this = Object<Type>{QJniObject::construct<Class>(std::forward<Args>(args)...)};
+    }
+
+    // named constructors avoid ambiguities
+    static Object<Type> fromJObject(jobject object) { return Object<Type>(object); }
+    template <typename ...Args>
+    static Object<Type> construct(Args &&...args)
+    {
+        return Object<Type>{QJniObject::construct<Class, Args...>(std::forward<Args>(args)...)};
+    }
+
+    // public API forwarding to QJniObject, with the implicit Class template parameter
+    template <typename Ret, typename ...Args
+#ifndef Q_QDOC
+        , QtJniTypes::ValidSignatureTypes<Ret, Args...> = true
+#endif
+    >
+    static auto callStaticMethod(const char *name, Args &&...args)
+    {
+        return QJniObject::callStaticMethod<Class, Ret, Args...>(name,
+                                                                 std::forward<Args>(args)...);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    static auto getStaticField(const char *field)
+    {
+        return QJniObject::getStaticField<Class, T>(field);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    static void setStaticField(const char *field, T &&value)
+    {
+        QJniObject::setStaticField<Class, T>(field, std::forward<T>(value));
+    }
+
+    // keep only these overloads, the rest is made private
+    template <typename Ret, typename ...Args
+#ifndef Q_QDOC
+        , QtJniTypes::ValidSignatureTypes<Ret, Args...> = true
+#endif
+    >
+    auto callMethod(const char *method, Args &&...args) const
+    {
+        return QJniObject::callMethod<Ret>(method, std::forward<Args>(args)...);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    auto getField(const char *fieldName) const
+    {
+        return QJniObject::getField<T>(fieldName);
+    }
+
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    void setField(const char *fieldName, T &&value)
+    {
+        QJniObject::setField(fieldName, std::forward<T>(value));
+    }
+
+private:
+    // The following declutters the API of these types compared to the QJniObject API.
+    // 1) 'Object' methods; the functions we have have return type auto and will return
+    //     the type specified by the template parameter.
+    using QJniObject::callObjectMethod;
+    using QJniObject::callStaticObjectMethod;
+    using QJniObject::getObjectField;
+    using QJniObject::getStaticObjectField;
+
+    // 2) Constructors that take a class name, signature string, or class template argument
+    explicit Object(const char *className) = delete;
+    explicit Object(const char *className, const char *signature, ...) = delete;
+    template<typename ...Args>
+    explicit Object(const char *className, Args &&...args) = delete;
+    explicit Object(jclass clazz, const char *signature, ...) = delete;
+    template<typename Class, typename ...Args>
+    static QJniObject construct(Args &&...args) = delete;
+
+    // 3) Overloads that take a class name/jclass, methodID, signature string, or an
+    //    explicit class template argument
+    template <typename Ret, typename ...Args>
+    auto callMethod(const char *methodName, const char *signature, Args &&...args) const = delete;
+    template <typename Ret, typename ...Args>
+
+    static auto callStaticMethod(const char *className, const char *methodName,
+                                 const char *signature, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, const char *methodName,
+                                 const char *signature, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, jmethodID methodId, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(const char *className, const char *methodName,
+                                 Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, const char *methodName, Args &&...args) = delete;
+    template <typename Klass, typename Ret, typename ...Args>
+    static auto callStaticMethod(const char *methodName, Args &&...args) = delete;
+
+    template <typename T>
+    static auto getStaticField(const char *className, const char *fieldName) = delete;
+    template <typename T>
+    static auto getStaticField(jclass clazz, const char *fieldName) = delete;
+    template <typename Klass, typename T>
+    static auto getStaticField(const char *fieldName) = delete;
+
+    template <typename T>
+    void setField(const char *fieldName, const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(const char *className, const char *fieldName, T value) = delete;
+    template <typename T>
+    static void setStaticField(const char *className, const char *fieldName,
+                               const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(jclass clazz, const char *fieldName,
+                               const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(jclass clazz, const char *fieldName, T value) = delete;
+    template <typename Klass, typename T>
+    static void setStaticField(const char *fieldName, T value) = delete;
 };
 
 } // namespace QtJniTypes
 
 #define Q_DECLARE_JNI_TYPE_HELPER(Type)                         \
 namespace QtJniTypes {                                          \
-struct Type : Object                                            \
+struct Type : Object<Type>                                      \
 {                                                               \
-    constexpr Type(jobject o) noexcept : Object{o} {}           \
+    using Object::Object;                                       \
 };                                                              \
 }                                                               \
 
diff --git a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
index 36f6f5923e5..49a814f1222 100644
--- a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
+++ b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
@@ -12,6 +12,7 @@ using namespace Qt::StringLiterals;
 
 static const char testClassName[] = "org/qtproject/qt/android/testdatapackage/QtJniObjectTestClass";
 Q_DECLARE_JNI_CLASS(QtJniObjectTestClass, testClassName)
+using TestClass = QtJniTypes::QtJniObjectTestClass;
 
 static const jbyte A_BYTE_VALUE = 127;
 static const jshort A_SHORT_VALUE = 32767;
@@ -152,6 +153,16 @@ void tst_QJniObject::ctor()
         QVERIFY(object.isValid());
     }
 
+    {
+        // from Qt 6.7 on we can construct declared classes through the helper type
+        QJniObject object = TestClass::construct();
+        QVERIFY(object.isValid());
+
+        // or even directly
+        TestClass testObject;
+        QVERIFY(testObject.isValid());
+    }
+
     {
         QJniObject string = QJniObject::fromString(QLatin1String("Hello, Java"));
         QJniObject object("java/lang/String", "(Ljava/lang/String;)V", string.object<jstring>());
@@ -311,10 +322,15 @@ void tst_QJniObject::className()
     }
 
     {
-        QJniObject strObject = QJniObject("java/lang/String", jString.object<jstring>());
+        QJniObject strObject = QJniObject("java/lang/String", str);
         QCOMPARE(strObject.className(), "java/lang/String");
         QCOMPARE(strObject.toString(), str);
     }
+
+    {
+        TestClass test;
+        QCOMPARE(test.className(), testClassName);
+    }
 }
 
 void tst_QJniObject::callStaticObjectMethodClassName()
@@ -1119,8 +1135,8 @@ void setStaticField(const char *fieldName, T testValue)
 
     // use template overload to reset to default
     T defaultValue = {};
-    QJniObject::setStaticField<QtJniTypes::QtJniObjectTestClass, T>(fieldName, defaultValue);
-    res = QJniObject::getStaticField<QtJniTypes::QtJniObjectTestClass, T>(fieldName);
+    TestClass::setStaticField(fieldName, defaultValue);
+    res = TestClass::getStaticField<T>(fieldName);
     QCOMPARE(res, defaultValue);
 }
 
@@ -1185,8 +1201,8 @@ void tst_QJniObject::setStaticObjectField()
 
     // as of Qt 6.7, we can set and get strings directly
     using namespace QtJniTypes;
-    QJniObject::setStaticField<QtJniObjectTestClass>("S_STRING_OBJECT_VAR", qString);
-    QCOMPARE((QJniObject::getStaticField<QtJniObjectTestClass, QString>("S_STRING_OBJECT_VAR")), qString);
+    QtJniObjectTestClass::setStaticField("S_STRING_OBJECT_VAR", qString);
+    QCOMPARE(QtJniObjectTestClass::getStaticField<QString>("S_STRING_OBJECT_VAR"), qString);
 }
 
 void tst_QJniObject::templateApiCheck()
@@ -1473,11 +1489,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jobjectArray>(testClassName,
                                                                           "staticObjectArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jobject[]>("staticObjectArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jobjectArray>("objectArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jobject[]>("objectArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jbooleanArray ------------------------------------------------------------------------------
@@ -1485,11 +1507,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jbooleanArray>(testClassName,
                                                                            "staticBooleanArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jboolean[]>("staticBooleanArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jbooleanArray>("booleanArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jboolean[]>("booleanArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jbyteArray ---------------------------------------------------------------------------------
@@ -1497,11 +1525,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jbyteArray>(testClassName,
                                                                         "staticByteArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jbyte[]>("staticByteArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jbyteArray>("byteArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jbyte[]>("byteArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jcharArray ---------------------------------------------------------------------------------
@@ -1509,11 +1543,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jcharArray>(testClassName,
                                                                         "staticCharArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jchar[]>("staticCharArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jcharArray>("charArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jchar[]>("charArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jshortArray --------------------------------------------------------------------------------
@@ -1521,11 +1561,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jshortArray>(testClassName,
                                                                          "staticShortArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jshort[]>("staticShortArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jshortArray>("shortArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jshort[]>("shortArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jintArray ----------------------------------------------------------------------------------
@@ -1533,11 +1579,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jintArray>(testClassName,
                                                                        "staticIntArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jint[]>("staticIntArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jintArray>("intArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jint[]>("intArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jlongArray ---------------------------------------------------------------------------------
@@ -1545,11 +1597,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jlongArray>(testClassName,
                                                                         "staticLongArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jlong[]>("staticLongArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jlongArray>("longArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jlong[]>("longArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jfloatArray --------------------------------------------------------------------------------
@@ -1557,11 +1615,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jfloatArray>(testClassName,
                                                                          "staticFloatArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jfloat[]>("staticFloatArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jfloatArray>("floatArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jfloat[]>("floatArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jdoubleArray -------------------------------------------------------------------------------
@@ -1569,11 +1633,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jdoubleArray>(testClassName,
                                                                           "staticDoubleArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jdouble[]>("staticDoubleArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jdoubleArray>("doubleArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jdouble[]>("doubleArrayMethod");
+        QVERIFY(array.isValid());
     }
 
 }
diff --git a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
index 856368355c7..0ce2295092d 100644
--- a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
+++ b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
@@ -5,6 +5,8 @@
 
 #include <QtCore/qjnitypes.h>
 
+using namespace Qt::StringLiterals;
+
 class tst_QJniTypes : public QObject
 {
     Q_OBJECT
@@ -15,6 +17,7 @@ public:
 private slots:
     void initTestCase();
     void nativeMethod();
+    void construct();
 };
 
 struct QtJavaWrapper {};
@@ -159,6 +162,35 @@ void tst_QJniTypes::nativeMethod()
     QCOMPARE(method.signature, "(ILjava/lang/String;J)Z");
 }
 
+void tst_QJniTypes::construct()
+{
+    using namespace QtJniTypes;
+
+    const QString text = u"Java String"_s;
+    String str(text);
+    QVERIFY(str.isValid());
+    QCOMPARE(str.toString(), text);
+
+    jobject jref = nullptr; // must be jobject, not jstring
+    {
+        // if jref would be a jstring, then this would call the
+        // Java String copy constructor!
+        String jstr(jref);
+        QVERIFY(!jstr.isValid());
+    }
+    jref = str.object<jstring>();
+    {
+        String jstr(jref);
+        QVERIFY(jstr.isValid());
+        QCOMPARE(jstr.toString(), text);
+    }
+
+    String str2 = str;
+    QCOMPARE(str.toString(), text);
+    String str3 = std::move(str2);
+    QCOMPARE(str3.toString(), text);
+}
+
 QTEST_MAIN(tst_QJniTypes)
 
 #include "tst_qjnitypes.moc"