JNI java本地开发接口
JNI 是一个协议
这个协议用来沟通java代码和外部的本地代码(c/c++).
通过这个协议,java代码就可以调用外部的c/c++代码
外部的c/c++代码也可以调用java代码
* 输出
#include <stdio.h> //standard input output
#include <stdlib.h>
main(){
printf("小志的逗比精神永存\n");
system("pause");
}
* C调用java的hello
public class Hello
{
public static void main(String[] dd){
System.out.println("hello from java");
}
}
#include <stdio.h>
#include <stdlib.h>
main(){
printf("hello from c\n");
system("java Hello");
system("pause");
}
* C的基本数据类型
char, int, float, double, long, short, signed, unsigned
#java的基本数据类型长度
* byte：1
* short：2
* int：4
* long：8
* boolean：1
* char：2
* float：4
* double：8
#c的基本数据类型长度
* short：2
* int：4
* long：4
* char：1
* float：4
* double：8
#include <stdio.h>
#include <stdlib.h>
main(){
//char, int, float, double, long, short, signed, unsigned
int i =3;
char c = 'a';
long long ago = 12314324;
short int i2 = 2;
long int i3 = 3243;
//printf("i的值为%d\n", i);
printf("char的长度:%d\n", sizeof(char));
printf("int的长度:%d\n", sizeof(int));
printf("float的长度:%d\n", sizeof(float));
printf("double的长度:%d\n", sizeof(double));
printf("long的长度:%d\n", sizeof(long));
printf("short的长度:%d\n", sizeof(short));
printf("long long的长度:%d\n", sizeof(long long));
printf("short int的长度:%d\n", sizeof(short int));
printf("long int的长度:%d\n", sizeof(long int));
system("pause");
}
* 输出函数
#include <stdio.h>
#include <stdlib.h>
/*
%d - int
%ld – long int
%hd – 短整型
%c - char
%f - float
%lf – double
%u – 无符号数
%x – 十六进制输出 int 或者long int 或者short int
%o - 八进制输出
%s – 字符串
*/
main(){
int i = -3;
long l = 34567;
char c = 'a';
float f = 3.1466666666;
double d = 3.1466666666;
char arr[] = "小志的二逼精神永存";
printf("%c\n", c);
printf("%d\n", i);
printf("%f\n", f);
printf("%lf\n", d);
printf("%u\n", i);
printf("%#x\n", l);
printf("%#o\n", l);
printf("%s\n", arr);
system("pause");
}
* 输入函数
#include <stdio.h>
#include <stdlib.h>
main(){
printf("请输入班级人数:\n");
int number;
//&：取出number的内存地址
scanf("%d", &number);
printf("请输入班级名称:\n");
char name[10];
scanf("%s", &name);
printf("number的地址%#x\n", &number);
printf("name的地址%#x\n", &name);
printf("班级人数为%d，名称为%s\n", number, name);
system("pause");
}
“*”的三种用法
1. 乘法
2. int* p：定义一个指针变量p，p中存放一个内存地址，这个地址所存放的数据规定是int型
3. *p：取出p中保存的内存地址存放的数据
* 指针和指针变量的关系
指针就是地址，地址就是指针
地址就是内存单元的编号
指针变量是存放地址的变量
指针和指针变量是两个不同的概念
但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
* 为什么使用指针
指针的重要性
直接访问硬件 (opengl 显卡绘图)
快速传递数据(指针表示地址)
返回一个以上的值(返回一个数组或者结构体的指针)
表示复杂的数据结构(结构体)
方便处理字符串
指针有助于理解面向对象
#include <stdio.h>
#include <stdlib.h>
main(){
int i = 3;
//定义一个保存int类型数据的地址的指针变量 ，该变量的值是一个内存地址
int* p = &i;
int** q = &p;
printf("i的地址%#x\n", p);
printf("i的值为%d\n", *p);
printf("i的值为%d\n", **q);
system("pause");
}
#include <stdio.h>
#include <stdlib.h>
main(){
//野指针：没有赋值的指针
int* p;
int i;
double d = 3.14;
p = &d;
//*p = 23;
printf("%#x\n", p);
printf("%lf\n", *p);
system("pause");
}
* 值交换（值传递： 所有语言所有平台，都只有值传递，引用传递传递的值是内存地址）
#include <stdio.h>
#include <stdlib.h>
void swap(int* p, int* q){
int temp = *p;
*p = *q;
*q = temp;
}
main(){
int i = 3;
int j = 5;
printf("i=%d\n", i);
printf("j=%d\n", j);
swap(&i, &j);
printf("i=%d\n", i);
printf("j=%d\n", j);
system("pause");
}
* 主函数取子函数的值
#include <stdio.h>
#include <stdlib.h>
void function(int** p){
int i = 3;
printf("i的地址为%#x\n", &i);
*p = &i;
}
main(){
int* mainp;
function(&mainp);
printf("主函数中获取i的地址为%#x\n", mainp);
//子函数执行完后，里面的局部变量就会销毁
//数据幻影 (如果上面两个打印被注释掉，那么在i的值被销毁之前，还是利用那么0.几秒的时候打印出来)
printf("主函数中获取i的值为%d\n", *mainp);
system("pause");
}
* 数组入门
#include <stdio.h>
#include <stdlib.h>
main(){
//数组的内存地址是连续的，但要注意不同数据类型所占的字节是不一样的。
//整个数组的内存地址就是第一个元素的内存地址，
//char arr[] = "hello";
int arr[] = {1,2,3,4,5};
printf("%#x\n", &arr[0]);
printf("%#x\n", &arr[1]);
printf("%#x\n", &arr[2]);
printf("%#x\n", &arr[3]);
printf("数组名字的地址%#x\n", &arr);
//char* p = &arr;
int* p = &arr;
//+1表示向右偏移一个单位
printf("%d\n", *(p+0));
printf("%d\n", *(p+1));
printf("%d\n", *(p+2));
printf("%d\n", (p+2)-p);
system("pause");
}
* 指针长度
#include <stdio.h>
#include <stdlib.h>
main(){
char* cp;
int* ip;
short* lizhip;
int i;
char c;
cp = &c;
ip = &i;
//指针的长度都是4个字节
printf("%d\n", sizeof(cp));
printf("%d\n", sizeof(ip));
printf("%d\n", sizeof(lizhip));
printf("%d\n", cp-ip);
system("pause");
}
* 堆 栈
##栈
* 系统自动分配和释放
* 保存全局、静态、局部变量
* 在栈上分配内存叫静态分配
* 大小一般是固定的
##堆
* 程序员手动分配（malloc/new）和释放（free/java不用手动释放）
* 在堆上分配内存叫动态分配
* 一般硬件内存有多大就有多大
堆和栈的区别:
1.申请方式
栈:
由系统自动分配.例如,声明一个局部变量int b; 系统自动在栈中为b开辟空间.例如当在调用涵数时，需要保存的变量，最明显的是在递归调用时，要系统自动分配一个栈的空间，后进先出的，而后又由系统释放这个空间.
堆:
需要程序员自己申请，并指明大小，在c中用malloc函数
如char* p1 = (char*) malloc(10); //14byte
但是注意p1本身是在栈中的.
2 申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
3.申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（vc编译选项中可以设置,其实就是一个STACK参数,缺省2M），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
4.申请效率的比较：
栈:由系统自动分配，速度较快。但程序员是无法控制的。
堆:由malloc/new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
5.堆和栈中的存储内容
栈:在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
6.内存的回收
栈上分配的内存，编译器会自动收回；堆上分配的内存，要通过free来显式地收回,否则会造成内存泄漏。
堆和栈的区别可以用如下的比喻来看出：
使用栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
* 栈上分配的就是静态内存，堆上分配的就是动态内存
学号管理系统
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
main(){
printf("请输入学生人数:");
int count;
scanf("%d", &count);
//根据学生人数去动态申请堆内存
int* p = malloc(sizeof(int) * count);
int i;
for(i = 0; i < count; i++){
printf("请输入第%d个学生学号：", i);
scanf("%d", p+i);
}
printf("请输入新增的学生人数：");
int newCount;
scanf("%d", &newCount);
p = realloc(p, sizeof(int) * (count + newCount));
for(i = count; i < count + newCount; i++){
printf("请输入第%d个学生学号：", i);
scanf("%d", p+i);
}
for(i = 0; i < count + newCount; i++){
printf("第%d个学生的学号是：%d\n", i, *(p+i));
}
system("pause");
}
* 多级指针
#include <stdio.h>
#include <stdlib.h>
main(){
int i = 3;
int* p = &i;
int** q = &p;
int*** l = &q;
printf("i的值为%d\n", ***l);
system("pause");
}
* 结构体（长度会自动补齐）
#include <stdio.h>
#include <stdlib.h>
void study(){
printf("吃饭睡觉打李志\n");
}
//定义一个结构体
struct student{
int age;
int height;
char sex;
//结构体中不能定义函数，但可以定义函数指针
void (*studyP)();
}
main(){
//定义结构体的变量
struct student st = {20, 180, 'm', study};
printf("%d\n", st.age);
printf("结构体的长度%d\n", sizeof(st));
//调用函数指针有三种写法
st.studyP();
struct student* stp = &st;
(*stp).studyP();
stp->studyP();
system("pause");
}
* 联合体（长度取最大的那个）
#include <stdio.h>
#include <stdlib.h>
main(){
//定义一个联合体
union{long long i; short s; char c} un;
un.i = 3;
printf("%d\n", un.i);
printf("联合体的长度%d\n", sizeof(un));
system("pause");
}
* 枚举
#include <stdio.h>
enum WeekDay
{
Monday = 10,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
};
int main(void)
{
//int day;
enum WeekDay day = Sunday;
printf("%d\n",day);
system("pause");
return 0;
}
* 自定义类型
#include <stdio.h>
#include <stdlib.h>
typedef int haha;
main(){
haha i = 3;
printf("%d\n", i);
system("pause");
}
NDK\platforms\android-19\arch-arm\user\include\jni.h中有C语言和JAVA语言之间的翻译