JNI/NDK入门指南之调用Java构造方法和父类实例方法
JNI/NDK入门指南之调用Java构造方法和父类实例方法
Android JNI/NDK入门指南目录
JNI/NDK入门指南之正确姿势了解JNI和NDK
JNI/NDK入门指南之JavaVM和JNIEnv
JNI/NDK入门指南之JNI数据类型，描述符详解
JNI/NDK入门指南之jobject和jclass
JNI/NDK入门指南之javah和javap的使用和集成
JNI/NDK入门指南之Eclipse集成NDK开发环境并使用
JNI/NDK入门指南之JNI动/静态注册全分析
JNI/NDK入门指南之JNI字符串处理
JNI/NDK入门指南之JNI访问数组
JNI/NDK入门指南之C/C++通过JNI访问Java实例属性和类静态属性
JNI/NDK入门指南之C/C++通过JNI访问Java实例方法和类静态方法
JNI/NDK入门指南之JNI异常处理
JNI/NDK入门指南之JNI多线程回调Java方法
JNI/NDK入门指南之正确姿势了解，使用，管理，缓存JNI引用
JNI/NDK入门指南之调用Java构造方法和父类实例方法
JNI/NDK入门指南之C/C++结构体和Java对象转换方式一
JNI/NDK入门指南之C/C++结构体和Java对象转换方式二
引言
在前面的章节我们学习了JNI/NDK入门指南之C/C++通过JNI访问Java实例属性和类静态属性和JNI/NDK入门指南之C/C++通过JNI访问Java实例方法和类静态方法，其中都有讲到调用构造函数来实例化一个对象，但是都没有详细介绍过，只是讲了一个大概的用法。在本章我们将深入挖掘，分别介绍一下初始化一个对象的两种方法，以及如何调用子类对象重写父类的实例方法。
一. 初探JNI对象操作相关函数
由于本章会牵涉到许多的对象操作的函数，所以还是老规矩让我们先行热热身了解了解JNI对象操作相关函数，后续再正式进入本章的主题。
1.1 AllocObject
函数原型: jobject AllocObject (JNIEnv *env, jclass clazz)
函数功能：创建一个未被初始化的Java对象并分配内存空间。
函数参数:
- env： JNIEnv接口指针
- clazz: Java类对象引用
返回值: 返回Java对象。如果无法创建该对象则返回NULL。
异常抛出：
- InstantiationException：如果该类为一个接口或抽象类。
- OutOfMemoryError：如果系统内存不足。
1.2 NewObject函数组
这是一系列函数组集合，功能都是一致，只是JNI根据参数传入方式的不同而定制了一系列的马甲给穿上，追根究底它们还是同一个东西。
函数原型:
jobject NewObject (JNIEnv *env , jclass clazz, jmethodID methodID, …) //参数附加在函数后面，通常使用该函数
jobject NewObjectA (JNIEnv *env , jclassclazz, jmethodID methodID, jvalue *args) //参数以指针形式附加
jobjec tNewObjectV (JNIEnv *env , jclassclazz, jmethodID methodID, va_list args) //参数以"链表"形式附加
函数组关系：
jobject NewObject(jclass clazz, jmethodID methodID, ...)
{
va_list args;
va_start(args, methodID);
jobject result = functions->NewObjectV(this, clazz, methodID, args);
va_end(args);
return result;
}
jobject NewObjectV(jclass clazz, jmethodID methodID, va_list args)
{ return functions->NewObjectV(this, clazz, methodID, args); }
jobject NewObjectA(jclass clazz, jmethodID methodID, jvalue* args)
{ return functions->NewObjectA(this, clazz, methodID, args); }
函数功能：通过构造方法methodID创建新的Java对象实例。这里的methodID一定要是Java类对象的构造方法的ID，并且要通过 GetMethodID() 获得，且调用时的方法名必须为 ，返回类型有且仅必须为 void (V)。
函数参数:
- env:JNIEnv接口指针
- clazz: Java类对象
- methodID构造函数的方法ID
- NewObject 的其它参数： …(这里不是省略) 传给构造函数的参数，可以为空
NewObjectA 的其它参数： args：传给构造函数的参数数组
NewObjectV 的其它参数： args：传给构造函数的参数 va_list
返回值: 返回Java对象实例，如果无法构造该对象，则会返回NULL。
异常抛出:
- InstantiationException: 如果该类为接口或抽象类时将会抛出该异常
- OutOfMemoryError: 如果分配给改进程的系统内存不足，将会抛出该异常
1.3 GetObjectClass
函数原型: jclass GetObjectClass (JNIEnv *env, jobject obj)
函数功能:根据Java对象实例获取Java类对象
函数参数:
- env: JNIEnv接口指针
- obj: Java对象实例
函数返回值: 返回Java类对象
1.4 IsInstanceOf
函数原型: jboolean IsInstanceOf (JNIEnv *env, jobject obj, jclass clazz)
函数功能： 判断测试对象是否为某个类的实例。
参数:
- env: JNIEnv接口指针
- obj: Java对象实例
- clazz： Java类对象
返回值: 如果obj是clazz的对象实例，则返回JNI_TRUE,否则返回JNI_FALSE。
1.5 IsSameObject
函数原型: jboolean IsSameObject (JNIEnv *env, jobject ref1, jobject ref2)
函数功能： 判断两个Java引用是否引用自同一个Java对象。
函数参数
- env: JNIEnv接口指针
- ref1： Java实例对象引用
- ref2： Java实例对象引用
返回值： 如果 ref1 和 ref2 引用同一 Java 对象或均为 NULL，则返回 JNI_TRUE。否则返回 JNI_FALSE，同时当ref2为NULL的时候可以用于检测弱全局引用是否被GC了。
1.6 CallNonvirtualMethod
这里的PrimitiveType指代的是一系列的JNI数据类型，如果是引用类型的话PrimitiveType用Object替代。
函数原型: NativeType CallNonvirtual
函数功能：调用被子类覆盖的父类方法，或者调用构造函数
使用说明: 在实际使用中，根据需要调用方法将 CallNonvirtual
void (*CallNonvirtualVoidMethod)(JNIEnv*, jobject, jclass,jmethodID, ...);
函数返回值： 返回调用Java方法的结果。
二. Java调用构造方法和调用父类实例方法
在开始JNI中调用构造方法和调用父类实例方法相关的介绍前，让我们看看在Java层是怎么做的，然后我们在JNI层照葫芦画瓢的实现。好了不多说了，直接上代码走起！
2.1 演示代码
定义一个Java父类People,代码如下：
import android.util.Log;
public class People {
private static final String TAG = "AccessSuperMethod";
public void feature() {
Log.e(TAG, "People Can Walk upright");// 人吗，当然是能直立行走
}
protected String name;
public People(String name) {
this.name = name;
Log.e(TAG, "People Construct call...");
}
public String getName() {
Log.e(TAG, "People.getName Call...");
return this.name;
}
}
定义一个Java子类Programmer继承People,代码如下：
package com.study.jni.object_opertate;
import android.util.Log;
public class Programmer extends People {
public Programmer(String name) {
super(name);
Log.e(TAG, "Programmer Construct call....");
}
private static final String TAG = "OPERATE_OBJECT";
@Override
public void feature() {
super.feature();
Log.e(TAG, "Ha ha, Programmer can coding");// 我会编程
}
@Override
public String getName() {
super.getName();
Log.e(TAG, "Programmer.getName Call...");
return "My name is " + this.name;
}
}
Java端测试代码:
private void operateJavaObject() {
People mPeople = new Programmer("Java");
mPeople.feature();
mPeople.getName();
}
运行演示
E/AccessSuperMethod( 7175): People Construct call...
E/AccessSuperMethod( 7175): Programmer Construct call....
E/AccessSuperMethod( 7175): People Can Walk upright
E/AccessSuperMethod( 7175): Ha ha, Programmer can coding
E/AccessSuperMethod( 7175): People.getName Call...
E/AccessSuperMethod( 7175): Programmer.getName Call...
2.2 源码分析
前面的代码非常简单，都是一些入门级的Java代码，当然这里也主要是为了演示使用。
(1) 上述的代码中定义了两个类People和Programmer并且是父子关系。People类中定义了feature方法和getName方法，Programmer继承自People并重写了feather和getName方法。
(2) 在测试代码中，首先定义了一个People类型的变量mPeople,并指向了Programmer类的实例对象，然后调用它的feather方法和getName方法。
(3) 在执行new Programmer(“Java”)这段代码时，会先为Programmer类分配内存空间(所分配的内存空间大小由Cat类的成员变量数量决定)，然后调用Programmer的带构造方法初始化对象。mPeople是People类型，单它指向的是Programmer实例对象的引用，而且Programmer重写了父类的feather和getName方法，并且在这两个方法里面我们也调用了父类的方法，即调用super，所以你看到了子类和父类都被调用了。这个都是Java的基本知识就不过多啰嗦了。
2.3 Java内存管理简要分析
写过C/C++ 的同学应该都有一个很深刻的内存管理概念，栈空间和堆空间，栈空间的内存大小受操作系统限制，由操作系统自动来管理，速度较快，所以在函数中定义的局部变量、函数形参变量都存储在栈空间。操作系统没有限制堆空间的内存大小，只受物理内存的限制，内存需要程序员自己管理。在 C 语言中用 malloc 关键字动态分配的内存和在 C++ 中用 new 创建的对象所分配内存都存储在堆空间，内存使用完之后分别用 free 或 delete/delete[] 释放。这里不过多的讨论 C/C++ 内存管理方面的知识，有兴趣的同学请自行百度。做 Java 的童鞋众所周知，写 Java 程序是不需要手动来管理内存的，内存管理那些烦锁的事情全都交由一个叫 GC 的线程来管理（当一个对象没有被其它对象所引用时，该对象就会被 GC 释放）。但我觉得 Java 内部的内存管理原理和 C/C++ 是非常相似的，上例中，People mPeople = new Programmer(“Java”)，局部变量 mPeople 存放在栈空间上，new Programmer(“Java”)创建的实例对象存放在堆空间，返回一个内存地址的引用，存储在mPeople变量中。这样就可以通过mPeople变量所指向的引用访问Programmer实例当中所有可见的成员了。
所以综上所述，创建一个Java对象的步骤分为如下：
- 为对象分配内存空间
- 初始化对象（调用对象的构造方法）
三. JNI调用Java构造方法和父类实例方法
在前面的篇章中，我们演示了怎么在Java中实现调用Java类的构造方法和父类实例方法，那么在本章我们将在JNI本地方法的世界里面来重复这一操作。
3.1 演示代码
Java端代码:
Java端Native方法定义JNIAccessMethodManager.java代码：
package com.study.jni.object_opertate;
public class AccessSuperMethod {
public native void callSuperInstanceMethod();
static {
System.loadLibrary("accessSuperMethod");
}
}
Java端测试代码:
private void operateAccessSuperMethod(){
AccessSuperMethod mAccessSuperMethod = new AccessSuperMethod();
mAccessSuperMethod.callSuperInstanceMethod();
}
JNI端代码:
Java的Native方法对应的com_study_jni_object_opertate_AccessSuperMethod.h代码如下：
/* DO NOT EDIT THIS FILE - it is machine generated */
#include #ifdef __cplusplus
}
#endif
#endif
对应的com_study_jni_object_opertate_AccessSuperMethod.cpp代码如下：
#include "com_study_jni_object_opertate_AccessSuperMethod.h"
#include " , "([BLjava/lang/String;)V");
//建立byte数组
jbyteArray bytes = (env)->NewByteArray( (jsize)strlen(str));
//将char* 转换为byte数组
(env)->SetByteArrayRegion( bytes, 0, (jsize)strlen(str), (jbyte*)str);
//设置String, 保存语言类型,用于byte数组转换至String时的参数
jstring encoding = (env)->NewStringUTF( "utf-8");
//将byte数组转换为java String,并输出
return (jstring)(env)->NewObject( strClass, ctorID, bytes, encoding);
}
//将jstring转换成char *
char* jstringToNative(JNIEnv *env, jstring jstr)
{
if ((env)->ExceptionCheck() == JNI_TRUE || jstr == NULL)
{
(env)->ExceptionDescribe();
(env)->ExceptionClear();
//printf("jstringToNative函数转换时,传入的参数str为空");
return NULL;
}
jbyteArray bytes = 0;
jthrowable exc;
char *result = 0;
if ((env)->EnsureLocalCapacity(2) < 0)
{
return 0; /* out of memory error */
}
jclass jcls_str = (env)->FindClass("java/lang/String");
jmethodID MID_String_getBytes = (env)->GetMethodID(jcls_str, "getBytes", "()[B");
bytes = (jbyteArray)(env)->CallObjectMethod(jstr, MID_String_getBytes);
exc = (env)->ExceptionOccurred();
if (!exc)
{
jint len = (env)->GetArrayLength( bytes);
result = (char *)malloc(len + 1);
if (result == 0)
{
//JNU_ThrowByName( "java/lang/OutOfMemoryError", 0);
(env)->DeleteLocalRef(bytes);
return 0;
}
(env)->GetByteArrayRegion(bytes, 0, len, (jbyte *)result);
result[len] = 0; /* NULL-terminate */
}
else
{
(env)->DeleteLocalRef( exc);
}
(env)->DeleteLocalRef( bytes);
return (char*)result;
}
/*
* Class: com_study_jni_object_opertate_AccessSuperMethod
* Method: callSuperInstanceMethod
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_study_jni_object_1opertate_AccessSuperMethod_callSuperInstanceMethod
(JNIEnv * env, jobject object)
{
/*****JNI中创建Programmer对象的实例，并调用其父类的feather和getName方法*****/
jclass cls_people = NULL;
jclass cls_programmer = NULL;
jmethodID mid_programmer_construct = NULL;
jmethodID mid_feather = NULL;
jmethodID mid_getName = NULL;
jobject obj_programmer = NULL;
//1.获取Programmer类的引用
cls_programmer = env->FindClass("com/study/jni/object_opertate/Programmer");
if(cls_programmer == NULL)
{
LOGE(TAG,"FindClass Programmer failed\n");
return;
}
//2.获取Programmer的构造方法的ID(构造方法的名统一为：，但是签名得根据具体情况确定)
mid_programmer_construct = env->GetMethodID(cls_programmer, "" , "(Ljava/lang/String;)V");
if(mid_programmer_construct == NULL)
{
LOGE(TAG,"GetMethodID failed\n" );
return;
}
//3.创建一个jstring对象作为Programmer构造函数的参数
jstring s_name = nativeTojstring(env,"Hello Programmer");
if(s_name == NULL)
{
LOGE(TAG,"nativeTojstring failed, may be memory not enough\n");
return;
}
//4.创建Programmer实例对象(调用构造方法，并初始化对象)
obj_programmer = env->NewObject(cls_programmer, mid_programmer_construct, s_name);
if(obj_programmer == NULL)
{
LOGE(TAG,"NewObject Programmer failed\n");
return;
}
//5.调用Programmer父类People的feather和getName方法
cls_people = env->FindClass("com/study/jni/object_opertate/People");
if(cls_people == NULL)
{
LOGE(TAG,"FindClass People failed\n");
return;
}
//6.判断obj_programmer是否是cls_people的实例
jboolean flag = env->IsInstanceOf(obj_programmer, cls_people);
if(flag)
{
LOGE(TAG,"obj_programmer IsInstanceOf cls_people\n");
}
flag = env->IsInstanceOf(obj_programmer, cls_programmer);
if(flag)
{
LOGE(TAG,"obj_programmer IsInstanceOf cls_programmer\n");
}
//获取父类People中的feather方法ID
mid_feather = env->GetMethodID(cls_people, "feature", "()V");
if(mid_feather == NULL)
{
LOGE(TAG,"GetMethodID feature failed\n");
return;
}
//7.调用CallNonvirtualVoidMethod获取被子类覆盖的父类方法,即Programmer父类的方法
//其中obj_programmer是Programmer的实例，cls_people是People的类引用，mid_feather是People类中的方法ID
env->CallNonvirtualVoidMethod(obj_programmer, cls_people, mid_feather);
//8.获取父类People中的getName方法ID
mid_getName= env->GetMethodID(cls_people, "getName", "()Ljava/lang/String;");
if(mid_getName == NULL)
{
LOGE(TAG,"GetMethodID getName failed\n");
return;
}
//9.调用CallNonvirtualVoidMethod获取被子类覆盖的父类方法,即Programmer父类的方法
//其中obj_programmer是Programmer的实例，cls_people是People的类引用，mid_getName是People类中的方法ID
s_name = (jstring)env->CallNonvirtualObjectMethod(obj_programmer, cls_people, mid_getName);
LOGE(TAG,"The peopel getName %s\n", jstringToNative(env, s_name));
exit:
//10.删除局部引用
env->DeleteLocalRef(s_name);
env->DeleteLocalRef(cls_people);
env->DeleteLocalRef(cls_programmer);
env->DeleteLocalRef(obj_programmer);
}
运行演示:
E/AccessSuperMethod( 8464): People Construct call...
E/AccessSuperMethod( 8464): Programmer Construct call....
I/AccessSuperMethod( 8464): obj_programmer IsInstanceOf cls_people
I/AccessSuperMethod( 8464): obj_programmer IsInstanceOf cls_programmer
E/AccessSuperMethod( 8464): People Can Walk upright
E/AccessSuperMethod( 8464): People.getName Call...
I/AccessSuperMethod( 8464): The peopel getName Hello Programmer
3.2 源码分析
好了，通过前面的代码，我们成功的在JNI中调用了Java构造方法和父类实例方法，那么下面让我们仔细分析分析，一一突破！
3.2.1 JNI调用Java构造方法
JNI调用Java构造方法其实和调用Java普通方法的步骤都是一样的，只是在细节上处理有一丁点区别，下面让我们跟着代码解读一下：
(1) 通过JNI函数FindClass获取Programmer的类引用，并且这里也一定要做异常处理，因为可能查找的类不存在。
(2) 通过JNI函数GetMethodID获取构造方法的MethodID，这里有一点一定要注意的就是构造方法的名字有且仅可能是""。这个读者也不要较真为啥一定是这个呢，因为有些规则是约定俗成的就是这样的。
(3) 调用JNI函数NewObject创建Programmer实例对象，这段代码主要做了两件事情
- 创建一个未被初始化的对象并分配内存空间
- 调用对象的构造函数初始化实例对象
上述的NewObject也可以使用其它JNI函数替代，即先为对象分配内存，然后再初始化对象，代码如下：
//方式二
// 1、创建一个未初始化的对象，并分配内存
obj_programmer= env->AllocObject(cls_programmer);
if (obj_programmer) {
// 2、调用对象的构造函数初始化对象
(env)->CallNonvirtualVoidMethod(obj_programmer, cls_programmer, mid_programmer_construct, s_name);
if (env->ExceptionCheck()) { // 检查异常
goto exit
}
AllocObject 函数创建的是一个未初始化的对象，后面在用这个对象之前，必须调用CallNonvirtualVoidMethod调用对象的构造函数初始化该对象。而且在使用时一定要非常小心，确保在一个对象上面，构造函数最多被调用一次。有时，先创建一个初始化的对象，然后在合适的时间再调用构造函数的方式是很有用的。尽管如此，大部分情况下，应该使用 NewObject，尽量避免使用容易出错的 AllocObject/CallNonvirtualVoidMethod 函数。
3.2.2 通过JNI调用Java父类实例方法
如果一个方法被定义在父类中，在子类中被覆盖，也可以调用父类中的这个实例方法。JNI 提供了一系列函数CallNonvirtualXXXMethod 来支持调用各种返回值类型的实例方法。下面我们参照前面的实例代码一一解读:
(1) 调用JNI函数FindClass获取Programmer父类的People的类对象引用。
(2) 调用JNI函数IsInstanceOf判断Programmer实例是否是People的实例引用，通过代码和逻辑分析我们都知道是的。
(3) 调用GetMethodID获取父类People中的faether方法ID。
(4) 最后调用JNI函数CallNonvirtualVoidMethod获取被子类覆盖的父类方法，这里传入的参数分别是子类对象Programmer实例，父类People对象引用，父类People方法feather的ID，当然CallNonvirtualVoidMethod 也可以被用来调用父类的构造函数。也许读者会说，这个场景存在吗，是的这个在实际开发当中是很少遇到的。但是掌握多一点招式，还是有必要的吗，这样才能解锁更多动作吗。
写在最后
各位读者看官朋友们，关于调用Java构造方法和父类实例方法就告一段落了。也不总结了，偷懒一次，因为确实没有啥好总结的。在最后麻烦读者朋友们如果本篇对你有帮助，关注和点赞一下，当然如果有错误和不足的地方也可以拍砖。