jni怎么编译c
① android jni程序（c++）如何编译适用于arm-v8指令集的32位程序
可以看到Android上层的Application和ApplicationFramework都是使用java编写，
底层包括系统和使用众多的LIiraries都是C/C++编写的。
所以上层Java要调用底层的C/C++函数库必须通过Java的JNI来实现。
下面将学习Android是如何通过Jni来实现Java对C/C++函数的调用。以HelloWorld程序为例：
第一步：
使用Java编写HelloWorld 的Android应用程序：
package com.lucyfyr;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class HelloWorld extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.v("fresne", printJNI("I am HelloWorld Activity"));
}
static
{
//加载库文件
System.loadLibrary("HelloWorldJni");
}
//声明原生函数 参数为String类型 返回类型为String
private native String printJNI(String inputStr);
}
这一步我们可以使用eclipse来生成一个App；
因为eclipse会自动为我们编译此Java文件，后面要是用到。
第二步：
生成共享库的头文件：
进入到eclipse生成的Android Project中 ：/HelloWorld/bin/classes/com/lucyfyr/
下：
可以看到里面后很多后缀为.class的文件，就是eclipse为我们自动编译好了的java文件，其中就有：
HelloWorld.class文件。
退回到classes一级目录：/HelloWorld/bin/classes/
执行如下命令：
javah com.lucyfyr.HelloWorld
生成文件:com_lucyfyr_HelloWorld.h
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_lucyfyr_HelloWorld */
#ifndef _Included_com_lucyfyr_HelloWorld
#define _Included_com_lucyfyr_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_lucyfyr_HelloWorld
* Method: printJNI
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI
(JNIEnv *, jobject, jstring);
#ifdef __cplusplus
}
#endif
#endif
可以看到自动生成对应的函数：Java_com_lucyfyr_HelloWorld_printJNI
Java_ + 包名（com.lucyfyr） + 类名(HelloWorld) + 接口名(printJNI)：必须要按此JNI规范来操作；
java虚拟机就可以在com.simon.HelloWorld类调用printJNI接口的时候自动找到这个C实现的Native函数调用。
当然函数名太长，可以在.c文件中通过函数名映射表来实现简化。
第三步：
实现JNI原生函数源文件：
新建com_lucyfyr_HelloWorld.c文件：
#include <jni.h>
#define LOG_TAG "HelloWorld"
#include <utils/Log.h>
/* Native interface, it will be call in java code */
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI(JNIEnv *env, jobject obj,jstring inputStr)
{
LOGI("fresne Hello World From libhelloworld.so!");
// 从 instring 字符串取得指向字符串 UTF 编码的指针
const char *str =
(const char *)(*env)->GetStringUTFChars( env,inputStr, JNI_FALSE );
LOGI("fresne--->%s",(const char *)str);
// 通知虚拟机本地代码不再需要通过 str 访问 Java 字符串。
(*env)->ReleaseStringUTFChars(env, inputStr, (const char *)str );
return (*env)->NewStringUTF(env, "Hello World! I am Native interface");
}
/* This function will be call when the library first be load.
* You can do some init in the libray. return which version jni it support.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
void *venv;
LOGI("fresne----->JNI_OnLoad!");
if ((*vm)->GetEnv(vm, (void**)&venv, JNI_VERSION_1_4) != JNI_OK) {
LOGE("fresne--->ERROR: GetEnv failed");
return -1;
}
return JNI_VERSION_1_4;
}
OnLoadJava_com_lucyfyr_HelloWorld_printJNI
函数里面做一些log输出 注意JNI中的log输出的不同。
JNI_OnLoad函数JNI规范定义的，当共享库第一次被加载的时候会被回调，
这个函数里面可以进行一些初始化工作，比如注册函数映射表，缓存一些变量等，
最后返回当前环境所支持的JNI环境。本例只是简单的返回当前JNI环境。
http://www.cnblogs.com/bastard/archive/2012/05/19/2508913.html
② 用jni在代码中怎样实现java层调c的源码
步骤一：
在java中定义一个c方法的接口 ,相当于在java代码中定义了一个接口 接口的实现方法是c语言实现的。
public native String hello();
步骤二：
实现C代码
方法名 严格按照jni的规范
#include <stdio.h>
#include <jni.h>
jstring Java_com_yys_helloworldformc_MainActivity_hello(JNIEnv* env,jobject obj){
// 2 步 实现C代码
// 返回一个java String 类型的字符串
//jstring (*NewStringUTF)(JNIEnv*, const char*);
//(*env) 相当于 JNINativeInterface* JNIEnv
//*(*env) 相当于 JNINativeInterface
///return (**env).NewStringUTF(env,"helloworldfromc");
return (*env)->NewStringUTF(env,"helloworldfromc");
}
步骤三：
创建android.mk 告诉编译器 如何把c代码打包成函数库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
# 对应打包成函数库的名字
LOCAL_MODULE := hello
# 对应c代码的文件
LOCAL_SRC_FILES := Hello.c
include $(BUILD_SHARED_LIBRARY)
步骤四：
把c代码 打包成函数库 用到了安装的环境 到相应目录下使用ndk-build打包
5
步骤五：
在java代码中 引入库函数
static{
System.loadLibrary("hello");// 注意事项 去掉前面的lib 后面的.so
}
③ 如何用java调用c语言编译器实现在线编译c语
要在java中调用c语言的库,需要使用Java提供了JNI。
举例说明
在c语言中定义一个 void sayHello()函数(打印Hello World);然后在Java中调用这个函数显示Hello Word.
现在分别从Java和C语言两部分说明:
1. Java 部分
首先定义一个HelloNative,在其中申明sayHello函数,函数要申明为Native 类型的.如下:
public class HelloNative {
public native void sayHello();
}
编译这个类,生成class文件:
javac HelloWorld.java
利用javah生成需要的h文件
javah HelloNative
生成的 h文件大概如下:
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class HelloNative */
#ifndef _Included_HelloNative
#define _Included_HelloNative
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: HelloNative
* Method: sayHello
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloNative_sayHello
(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
可以看一下上面自动生成的程序,程序include了jni.h,这个头文件在 $JAVA_HOME下的include文件夹下. 还可以发现生成的函数名是在之前的函数名前面加上了Java_HelloNative。
2. C语言部分
根据上面生成的h文件编写相应的代码实现,建立一个 HelloNative.cpp用来实现显示Hello World的函数.如下:
#include <stdio.h>
#include "HelloNative.h"
JNIEXPORT void JNICALL Java_HelloNative_sayHello(JNIEnv *, jobject)
{
printf("Hello World!\n");
}
代码编写完成之后,我们再用gcc编译成库文件,命令如下;
gcc -fPIC -I/usr/lib/jvm/java-7-openjdk-i386/include -I/usr/lib/jvm/java-7-openjdk-i386/include/linux -shared -o libHelloNative.so HelloNative.cpp
这样就会在当前目录下生成一个libHelloNative.so的库文件.这时需要的库已经生成,在C语言下的工作已经完成了.
接下来需要在Java中编写一个程序测试一下.在程序前,需要将我们的库载入进去.载入的方法是调用Java的 System.loadLibrary("HelloNative");
public class TestNative
{
static {
try {
System.loadLibrary("HelloNative");
}
catch(UnsatisfiedLinkError e) {
System.out.println( "Cannot load hello library:\n " + e.toString() );
}
}
public static void main(String[] args) {
HelloNative test = new HelloNative();
test.sayHello();
}
}
但是再编译后,运行的时候,问题又出现了.
Cannot load hello library:
java.lang.UnsatisfiedLinkError: no HelloNative in java.library.path
Exception in thread "main" java.lang.UnsatisfiedLinkError: HelloNative.sayHello()V
at HelloNative.sayHello(Native Method)
at TestNative.main(TestNative.java:13)
载入库失败,但是库明明就是放在当前文件夹下的,怎么会载入失败呢?
用System.getProperty("java.library.path")查看,发现java.library.path中并不u存在当前的目录.主要有以下的几个解决办法:
1) 将生成的库复制到java.library.path有的路径中去,当然这样不是很好
2) 设置环境变量export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH ,将当前的目录加入到LD_LIBRARY_PATH中
3) 设置java 的选项,将当前的目录加入到其中 .java -Djava.library.path=. $LD_LIBRARY_PATH
这样之后程序就能够成功的运行了.可以看见显示的"Hello World!"了
④ 怎么用jni
·编写带有native声明的方法的java类·使用javac命令编译所编写的java类·使用javah ?jni java类名生成扩展名为h的头文件·使用C/C++实现本地方法·将C/C++编写的文件生成动态连接库·ok 1) 编写java程序：这里以HelloWorld为例。 代码1：class HelloWorld { public native void displayHelloWorld(); static { System.loadLibrary("hello"); } public static void main(String[] args) { new HelloWorld().displayHelloWorld(); } } 声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。 Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法 displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary();的参数“hello”是动态库的名字。2) 编译 没有什么好说的了 javac HelloWorld.java 3) 生成扩展名为h的头文件 javah ? jni HelloWorld 头文件的内容： /* DO NOT EDIT THIS FILE - it is machine generated */ 1. include /* Header for class HelloWorld */ 1. ifndef _Included_HelloWorld 2. define _Included_HelloWorld 3. ifdef __cplusplus extern "C" { 1. endif /* * Class: HelloWorld * Method: displayHelloWorld * Signature: ()V * / JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject); 1. ifdef __cplusplus } 1. endif 2. endif （这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个 Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。4) 编写本地方法实现和由javah命令生成的头文件里面声明的方法名相同的方法。 代码2：1 #include "jni.h" 2 #include "HelloWorld.h" 3 //#include other headers 4 JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj) { printf("Hello world!\n"); return; } 注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、 jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为 HelloWorldImpl.c就ok了。5) 生成动态库 这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。 cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll 注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。6) 运行程序 java HelloWorld就ok.下面是一个简单的例子实现打印一句话的功能，但是用的c的printf最终实现。一般提供给java的jni接口包括一个so文件（封装了c函数的实现）和一个java文件（需要调用path的类）。1． JNI的目的是使java方法中能够调用c实现的一些函数，比如以下的java类，就需要调用一个本地函数testjni（一般声明为private native类型），首先需要创建文件weiqiong.java，内容如下：class weiqiong { static { System.loadLibrary("testjni");//载入静态库，test函数在其中实现 } private native void testjni(); //声明本地调用 public void test() { testjni(); } public static void main(String args[]) { weiqiong haha = new weiqiong(); haha.test(); } }2．然后执行javac weiqiong.java，如果没有报错，会生成一个weiqiong.class。3．然后设置classpath为你当前的工作目录，如直接输入命令行：set classpath = weiqiong.class所在的完整目录（如 c:\test)再执行javah weiqiong，会生成一个文件weiqiong.h文件，其中有一个函数的声明如下：JNIEXPORT void JNICALL Java_weiqiong_testjni (JNIEnv *, jobject);4．创建文件testjni.c将上面那个函数实现，内容如下：1. include2. includeJNIEXPORT void JNICALL Java_weiqiong_testjni (JNIEnv *env, jobject obj) { printf("haha---------go into c!!!\n"); }5．为了生成.so文件，创建makefile文件如下：libtestjni.so:testjni.o makefile gcc -Wall -rdynamic -shared -o libtestjni.so testjni.o testjni.o:testjni.c weiqiong.h gcc -Wall -c testjni.c -I./ -I/usr/java/j2sdk1.4.0/include -I/usr/java/j2sdk1.4.0/include/linux cl: rm -rf *.o *.so 注意：gcc前面是tab空，j2sdk的目录根据自己装的j2sdk的具体版本来写，生成的so文件的名字必须是loadLibrary的参数名前加“lib”。6．export LD_LIBRARY_PATH=.，由此设置library路径为当前目录，这样java文件才能找到so文件。一般的做法是将so文件到本机的LD_LIBRARY_PATH目录下。7．执行java weiqiong，打印出结果：“haha---------go into c!!!”在首次使用JNI的时候有些疑问，后来在使用中一一解决，下面就是这些问题的备忘：1。 java和c是如何互通的？其实不能互通的原因主要是数据类型的问题，jni解决了这个问题，例如那个c文件中的jstring数据类型就是java传入的String对象，经过jni函数的转化就能成为c的char*。对应数据类型关系如下表：Java 类型 本地c类型 说明 boolean jboolean 无符号，8 位 byte jbyte 无符号，8 位 char jchar 无符号，16 位 short jshort 有符号，16 位 int jint 有符号，32 位 long jlong 有符号，64 位 float jfloat 32 位 double jdouble 64 位 void void N/AJNI 还包含了很多对应于不同 Java 对象的引用类型如下图：2. 如何将java传入的String参数转换为c的char*，然后使用?java传入的String参数，在c文件中被jni转换为jstring的数据类型，在c文件中声明char* test，然后test = (char*)(*env)->GetStringUTFChars(env, jstring, NULL);注意：test使用完后，通知虚拟机平台相关代码无需再访问：(*env)->ReleaseStringUTFChars(env, jstring, test);3. 将c中获取的一个char*的buffer传递给java？这个char*如果是一般的字符串的话，作为string传回去就可以了。如果是含有’\0’的buffer，最好作为bytearray传出，因为可以制定的length，如果到string，可能到’\0’就截断了。有两种方式传递得到的数据：一种是在jni中直接new一个byte数组，然后调用函数(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);将buffer的值到bytearray中，函数直接return bytearray就可以了。一种是return错误号，数据作为参数传出，但是java的基本数据类型是传值，对象是传递的引用，所以将这个需要传出的byte数组用某个类包一下，如下：class RetObj { public byte[] bytearray; } 这个对象作为函数的参数retobj传出，通过如下函数将retobj中的byte数组赋值便于传出。代码如下： jclass cls; jfieldID fid; jbyteArray bytearray; bytearray = (*env)->NewByteArray(env,len); (*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer); cls = (*env)->GetObjectClass(env, retobj); fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]); (*env)->SetObjectField(env, retobj, fid, bytearray);4. 不知道占用多少空间的buffer，如何传递出去呢？在jni的c文件中new出空间，传递出去。java的数据不初始化，指向传递出去的空间即可。 你还费解吗</SPAN></SPAN></SPAN></SPAN>
</p>
⑤ java通过jni怎么调用c
只提供思路，自己去摸索，这样才能吧知识转化为自己的
1、编译一个class类 里面定义一个函数，注意要用native关键字，这是 jni入口的标志
比如 public int native jniSum(int a, int b) ;
不需要实现这个函数，像定义接口一样。
2、使用jdk里面的一个工具 exe，叫什么 jnih.exe 忘了。敲命令通过这个class 生成一个同名的 .h 文件 .h 里面会包含包路径的。
3、然后你就可以自己写 C/C++代码，实现 .h里 生成的 jniSum的 C版本的函数了
4，然后将这个C/C++的代码编译生成一个 dll 比如名字叫 LibJniSum.dll
5，在你的 class类里，加入静态引用
static {
System.loadLibrary("LibJniSum") ;//不要 后缀。
}
只要程序找得到你的 dll，就会自动加载dll
然后你就可以直接调用你的 jniSum了
⑥ 怎样用 jni来交互java与 c/c++
JNI是Java Native Interface的缩写，中文为JAVA本地调用。使用JNI可以很方便的用我们的Java程序调用C/C++程序。很多时候，某些功能用Java无法实现，比如说涉及到底层驱动的一些功能，这时候我们就可以利用JNI来调用C或者C++程序来实现，这就是JNI的强大之处。但是JNI也有它的缺点，使用java与本地已编译的代码交互，通常会丧失平台可移植性。
下面是一个JNI例子，调用C++输出"hello world"：
第一步：创建Java类，在里面定义一个本地方法（用native关键字修饰的方法）
public native void sayHello();
第二步：使用javah命令（javah 类的全路径）生成本地方法的C++头文件
在DOS窗口中进入工程所在目录，然后执行javah com.test.TestNative命令，执行完之后就会在当前目录生成一个后缀名为.h的头文件，如com_test_TestNative.h，这个头文件是根据包名和类名来命名的。
1 /* DO NOT EDIT THIS FILE - it is machine generated */
2 #include <jni.h>
3 /* Header for class com_test_TestNative */
4
5 #ifndef _Included_com_test_TestNative
6 #define _Included_com_test_TestNative
7 #ifdef __cplusplus
8 extern "C" {
9 #endif
10 /*
11 * Class: com_test_TestNative
12 * Method: sayHello
13 * Signature: ()V
14 */
15 JNIEXPORT void JNICALL Java_com_test_TestNative_sayHello
16 (JNIEnv *, jobject);
17
18 #ifdef __cplusplus
19 }
20 #endif
21 #endif
15、16行是对TestNative类中的本地方法sayHello()的声明。这个h文件相当于我们在java里面的接口，这里声明了一个 Java_com_test_TestNative_sayHello (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致。
第三步：编写C/C++本地代码，生成动态链接库文件
首先在VC6.0（当然也可以用其他工具）中创建一个dll工程---Win32 Dynamic-Link Library工程。然后将上面生成的头文件com_test_TestNative.h添加到该工程中，然后创建一个源文件引用该头文件并且实现头文件中本地函数的功能：
1 #include<iostream.h>
2 #include"com_test_TestNative.h"
3
4 JNIEXPORT void JNICALL Java_com_test_TestNative_sayHello(JNIEnv *env, jobject obj)
5 {
6 cout<<"hello world!"<<endl;
7 }
这里因为com_test_TestNative.h中引入了jni.h所以要将jni.h加入到VC6.0安装目录下的Include目录中。jni.h在JDK安装目录下的include中，同时得件include/win32中的两个头文件jawt_md.h、jni_md.h也导入到VC6.0中。
将所依赖的头文件导入之后，我们就可以构建该工程了，按F7就行了，完了会在工程目录中的Degug目录下生成一个动态链接库文件，我这里生成的是NativeCode.dll。我们就可以将该dll文件拷贝到环境变量path所包含的目录下给咱们的Java程序调用了，为了方便，我们也可以将dll所在的工程目录加入到环境变量path中去，这样可以避免每次都要拷贝的麻烦。注意修改环境变量之后要重启myeclipse。
第四步：Java调用本地函数
1 package com.test;
2
3 public class TestNative {
4 public native void sayHello();
5
6 /**
7 * @param args
8 */
9 public static void main(String[] args) {
10 System.loadLibrary("NativeCode");
11 TestNative tNative = new TestNative();
12 tNative.sayHello();
13 }
14 }
第10行是加载动态链接库，JVM只需要加载一次就可以调用了，“NativeCode”是上面生成的动态链接库的名字，不含后缀名。
运行该程序，成功打印输出了"hello world"。
⑦ 怎么样在Java程序中调用c/c++编译器进行c/c++的编译
可以调用的，java有一种技术叫JNI，就是为了调用C/C++，至于例子嘛是这样的： 01. public class testdll 02. { 03. static 04. { 05. System.loadLibrary("goodluck"); 06. } 07. public native static int get(); 08. 09. public native static void set(int i); 10. public static void main(String args) 11. { 12. testdll test = new testdll(); 13. test.set(10); 14. System.out.println(test.get()); 15. } 16. 17. } 用javac testdll.java编译它，会生成testdll.class。 再用javah testdll，则会在当前目录下生成testdll.h文件，这个文件需要被C/C++程序调用来生成所需的库文件。 二、C/C++中所需要做的工作 对于已生成的.h头文件，C/C++所需要做的，就是把它的各个方法具体的实现。然后编译连接成库文件即可。再把库文件拷贝到JAVA程序的路径下面，就可以用JAVA调用C/C++所实现的功能了。 好，下面我们用testdll.cpp文件具体实现这两个函数： 01. #include "testdll.h" 02. int i = 0; 03. JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass) 04. { 05. return i; 06. } 07. JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint j) 08. { 09. i = j; 10. } 编译连接成库文件，本例是在WINDOWS下做的，生成的是DLL文件。并且名称要与JAVA中需要调用的一致，这里就是goodluck.dll http://ask.wangmeng.cn/question/88
⑧ 关于jni方法调用本地vc++程序，c++程序中含有包含的头文件和lib库文件，请问jni方法怎么正确调用这个程序
jni的HelloWorld：
1.编写java部分，本地方法用关键字native表示，不用带方法体， 如：private native void helloworld（）；
2.使用命令行，linux与windos一样，在.java文件目录中使用javac，将其专为.class文件。若java部分带包，则在包的 上一级使用javah，如bin\com\fhy\jnitest\HelloWorld.class 则在bin\下使用javah并且要带包名，如javah com.fhy.HelloWorld，若无包则在.class目录中使 用。
3.将生成的.h文件放入vc的工程中并引入，在本地方法实现时，对于vc，在方法实现前部加入extern “C”，使编译器用C编译器编 译，而不是C++，后者可能导致函数名发生变化
4.将生成的.dll放入java工程目录中，jni部分完成
c++的没做过，应该是完全一样只用修改extern部分吧
⑨ jni 调用c和c++的区别
没有本质区别。但是要注意C++的name mangling的问题。
JNI通过函数名找函数入口，执行函数里的内容。这和函数用什么语言生成的并没有关系。只要保证函数名称符合JNI的协议。而C++要注意的是C++默认生成的函数名称和你写在源文件中的名称并不相同，因为C++要处理函数重载，会在函数名称中加上参数信息，这称为name mangling。解决方法是定义函数时在前面加上extern "C"修饰，告诉编译器这函数要被C调用（当然，其实是JNI），要保留源码中的函数名。比如：
extern "C" jint Java_com_goo_Foo_bar(JNIEnv *, jobject);
另外C++下，JNIEnv等结构体是作为类存在的，其中的函数可以直接用成员函数的语法调用。
⑩ 求java JNI调用c程序
首先写一个GoodLuck 类，里面包含native本地方法，这是用作C/C++实现的。也就是用C/c++实现java的native方法。
public class GoodLuck {
private String string="";
private int num;
public GoodLuck() {
}
static {
System.out.println(System.getProperty("java.library.path"));
System.loadLibrary("goodluck");
}
public native static String getString();
public native static String getInt();
public native static void printOutString();
public native static void printOutInt();
public static void main(String args[]){
GoodLuck gl = new GoodLuck();
gl.getString();
gl.getInt();
gl.printOutString();
gl.printOutInt();
}
}
然后用 javac命令运行GoodLuck.java文件,生成GoodLuck.class文件：javac GoodLuck.java，然后再用javah运行GoodLuck.class文件：javah GoodLuck。生成GoodLuck.h。GoodLuck.h的内容为：
/* DO NOT EDIT THIS FILE - it is machine generated */
#include "jni.h"
/* Header for class GoodLuck */
#ifndef _Included_GoodLuck
#define _Included_GoodLuck
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: GoodLuck
* Method: getString
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_GoodLuck_getString
(JNIEnv *, jclass);
/*
* Class: GoodLuck
* Method: getInt
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_GoodLuck_getInt
(JNIEnv *, jclass);
/*
* Class: GoodLuck
* Method: printOutString
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_GoodLuck_printOutString
(JNIEnv *, jclass);
/*
* Class: GoodLuck
* Method: printOutInt
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_GoodLuck_printOutInt
(JNIEnv *, jclass);
#ifdef __cplusplus
}
#endif
#endif
然后用VC6.0新建工程testdll（注意：工程为MFC AppWizard(dll)工程）
然后记得将GoodLuck.h引入，还有jni.h（在jdk目录下），最后用C++实现这几个方法，编译后找到生成的dll文件，重命名为goodluck.dll，复制该dll文件与GoodLuck.class同目录下，运行java GoodLuck，就可以了。