首页 > 代码库 > JNI_01

JNI_01

2024-09-24 02:38:09   213人阅读

JNI简介

java native interface
java 本地 接口
native  本地  一个操作系统使用什么语言开发的 这种语言对于这个操作系统来说就是本地语言
windows c/c++  linux c/c++  android 实际是linux 对于android来说 native语言 c/c++
 
对于当前Android平台来说 JNI就是
java c/c++ 接口
 
技术分享
 技术分享

 

JNI 的应用场景
① c/c++   c 硬件驱动  android 系统 驱动一些自己加进来的硬件  java操作硬件
java 可以通过jni调用c开发的硬件的驱动  实现对硬件的控制
② java 一处编译到处运行 解释型语言 运行在虚拟机上 效率相对低一些 
    游戏和音视频解码  图形图像处理   c++/c  
    彩票公司   复式投注 
通过jni可以提高程序的效率 复杂运算交给c/c++处理
 
③ 安全角度   加密的算法   登陆用户名密码加密的逻辑通过jni放到c/c++
 
④ 可以使用C/C++ 开源免费的库  1972年  1995年
ffmpeg  openCV 图像处理 计算机视觉 人脸识别
 
JNI 
java
native  本地语言  c/c++    c的基本的语法   能看懂会调用
interface   接口  NDK  native develop kit  
 

C的基本的语法

1.Helloworld

  1. #include<stdlib.h> 相当于java import .h c的头文件 std standard 标准的 lib library 标准函数库
  2. #include<stdio.h> standard io 标准输入输出流 相当于 java.lang
  3. main(){ //c程序的入口 public static void main(String ars[])
  4. printf("hello world!\n");//向控制台输出一句话 system.out.print "\n"换行符
  5. system("notepad");
  6. system("calc");
  7. system("pause"); //system调用系统底层的命令 在当前的这个程序中 调用windows命令
  8. }
 

2.C的基本数据类型 

java基本数据类型                              c基本数据类型
boolean      1                                        没有boolean 0(false)或非0(true)
byte            1                                        没有byte
char            2                                        char       1
short           2                                        short
int               4                                        int
long            8                                         long     4字节  long long 8字节
float            4                                        float
double        8                                        double
 
c的数据类型  有符号(signed) 无符号(unsigned)只能用来修饰整形变量   short int long   char 默认都是signed有符号的
signed 有符号  最高位是符号位       可以表示负数  表示的最大值相对要小
unsigned 无符号  最高位是数值位   不可以表示负数 表示的最大值相对大
技术分享
 技术分享

 

 
3.C的输出函数
    占位符的用法  占位符和类型要一一对应 
   c的字符串 实际上就是char数组
   java的数组和C声明的方式有区别
   C声明一个数组   只能把中括号放到变量名的后面
char array[] 
char array[] = {‘a‘,‘b‘,‘\0‘}; \0结束符
char array[] = "hello";
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. /*输出函数
  4. printf("要输出的内容+占位符",.......)
  5. 常用占位符
  6. %d - int
  7. %ld – long int
  8. %lld - long long
  9. %hd – 短整型 short 2字节
  10. %c - char
  11. %f - float
  12. %lf – double
  13. %u – 无符号数
  14. %x – 十六进制输出 int 或者long int 或者short int
  15. %o - 八进制输出
  16. %s – 字符串
  17. */
  18. // 12345678 10111100 01100001 01001110
  19. //24910 1100001 01001110
  20. main(){
  21. int i = 12345678;
  22. char c = ‘a‘;
  23. short s = 1234;
  24. long l = 12345678;
  25. float f = 3.14;
  26. double d = 3.1415926;
  27. printf("int i = %d\n",i);
  28. printf("char c = %c\n",c);
  29. printf("short s = %hd\n",s);
  30. printf("long l = %ld\n",l);
  31. printf("float f = %.2f\n",f);//printf输出小数会截取6位有效数字 不足6位补0 超过6为四舍五入
  32. printf("double d = %.7lf\n",d); // &.2f保留两位有效数字
  34. printf("int i = %#x\n",i); // %#x %#o 可以给16进制输出和8进制输出添加前缀
  35. printf("int i = %#o\n",i);
  37. //java 字符串 String
  38. //c字符串实际就是一个字符数组 char
  39. //c数组的声明 和java的区别 c的数组不检测越界 表示字符串的结束 \0
  40. char array[] = {‘a‘,‘b‘,‘c‘,‘d‘,‘\0‘};
  41. printf("c的字符串array=%s\n",array);
  42. char array2[] = "你好";
  43. printf("array2=%s\n",array2);
  44. system("pause");
  45. }
 技术分享

 

4.C的输入函数
c的数组不检测越界  注意结束符也会占一个字节
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. /*
  4. 输入函数 Scanf
  5. Int len;
  6. Scanf(“%d”,&len); &取地址符号
  7. 数组不检测越界
  9. */
  10. main(){
  11. printf("请输入班级的人数:");
  12. int count;
  13. scanf("%d",&count); //取出count的地址 用户的输入就会保存到count这个变量中
  14. printf("班级人数为%d\n",count);
  15. char name[4];
  16. printf("cound的地址%d,name的地址%d\n",&count,&name);
  17. printf("请输入班级的名字:");
  18. scanf("%s",&name);
  19. printf("班级的人数%d,班级的名字%s",count,name);
  21. system("pause");
  22. }
 
 
技术分享
 
5.内存地址的概念
当程序声明一个变量就会在内存中为这个变量申请一块内存 这个内存对应着一个编号 这个编号就是内存地址
没有编号的内存是没法使用的
 技术分享

 

内存最小单位 byte
 
32操作系统(能够驱动的地址总线32位(32根) ) 最大支持几G内存   4G内存
2^32   能够有这么多个编号给内存使用 
技术分享
 
5.1内存地址修改
 
6.C的指针 ☆☆☆☆☆
   指针 通过一个变量来保存一个变量内存地址 这个变量就是指针变量
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. // 变量的类型 * 变量名
  4. // int* p pointer int* p int * p int *p
  5. //由于把i的地址保存到了指针变量p中 *p 等价于 i
  6. main(){
  7. int i = 123;
  8. //p就是一个指针变量
  9. int* p = &i;
  10. printf("*p = %d\n",*p);
  11. *p = 456;
  12. printf("i = %d\n",i);
  13. system("pause");
  14. }
 技术分享

 

 
技术分享
 
指针常见的错误
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. main(){
  4. //java如果声明一个变量 如果是基本数据类型会帮助你初始化
  5. //①野指针 指针变量声明之后没有初始化 直接通过*p= 做赋值操作 就叫野指针
  6. //避免野指针
  7. //②指针的类型和保存的地址类型要匹配 int类型的指针要指向int类型的地址
  8. //double类型的指针 要保存一个double类型的变量地址
  9. //int i;
  10. double i = 123.4567;
  11. int* p = &i;
  12. printf("p = %#x\n",p);
  13. *p = 1234;
  14. printf("i = %lf\n",i);
  15. system("pause");
  16. }
①野指针  指针变量声明之后 没有初始化 直接通过*p=  做赋值的操作 
   开发的时候要避免野指针
int* p;   *p = 4567;
用自己程序声明的变量 取出变量的地址 为指针变量赋初始值
② 指针的类型和保存的地址对应的数据类型要匹配
 
7.C指针的练习
  ①交换两个数
技术分享

 

技术分享
值传递          引用传递 实际上值传递和引用传递 传递的都是普通的数值 只不过引用传递 传递的值比较特殊 是一个变量的地址值
获取到变量的地址值之后 可以通过指针变量 直接操作内存地址对应的内存
 
如果想通过执行一个函数 不经过返回值 直接修改main函数中的临时变量的值只能通过引用传递 值传递做不到
java只有值传递 不能做引用传递
② 返回多个值
  
  1. #include<stdlib.h>
  2. #include<stdio.h>
  4. void function(int* p ,int *q){
  5. *p *= 2;
  6. *q *= 2;
  7. }
  9. main(){
  10. int i = 123;
  11. int j = 456;
  12. function(&i,&j);
  13. printf("i = %d\n",i);
  14. printf("j = %d\n",j);
  15. system("pause");
  16. }
8.指针和数组之间的关系
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //①数组占用一块连续的内存空间
  4. //② 数组的名字的地址实际上就是数组的第一个元素的地址 就是数组的首地址
  5. // ③ 通过指针变量指向数组的第一个元素的地址 就可以访问到其余元素 访问的方式就是通过指针的位移运算 +1 +2
  6. //跟通过索引访问数组是一样的
  7. //④ 通过指针位移的方式访问数组需要注意 指针每+1 究竟移动几个字节跟 指针变量的类型有关
  8. //int* p p+1移动4个字节 char* p p+1移动1个字节
  9. main(){
  10. // char array[] = {‘a‘,‘b‘,‘c‘,‘d‘,‘\0‘};
  11. int array[] = {1,2,3,4};
  12. printf("array[0]的地址是%#x\n",&array[0]);
  13. printf("array[1]的地址是%#x\n",&array[1]);
  14. printf("array[2]的地址是%#x\n",&array[2]);
  15. printf("array[3]的地址是%#x\n",&array[3]);
  17. printf("array的地址是%#x\n",&array);
  18. //数组变量名的地址实际上就是数组的首地址(第一个元素的地址)
  20. char* p = &array[0];
  21. //int* p = &array;
  22. // p = &array;
  24. printf("p = %#x\n",p);
  25. printf("p+1 = %#x\n",p+1);
  26. printf("p+2 = %#x\n",p+2);
  27. printf("p+3 = %#x\n",p+3);
  28. /*
  29. printf("*(p+0)= %c\n",*(p+0));
  30. printf("*(p+1)= %c\n",*(p+1));
  31. printf("*(p+2)= %c\n",*(p+2));
  32. printf("*(p+3)= %c\n",*(p+3));
  33. */
  35. printf("*(p+0)= %d\n",*(p+0));
  36. printf("*(p+1)= %d\n",*(p+1));
  37. printf("*(p+2)= %d\n",*(p+2));
  38. printf("*(p+3)= %d\n",*(p+3));
  39. printf("*(p+4)= %d\n",*(p+4));
  40. system("pause");
  41. }
② c的字符串定义最常用的方式
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. main(){
  4. char str[] = {‘a‘,‘b‘,‘c‘,‘d‘,‘\0‘};
  5. char str1[] = "你好";
  6. printf("str的地址= %#x\n",str);
  7. printf("str的地址= %#x\n",&str);
  8. char* str2 = str;
  9. //c定义字符串最常用的方式 char * str = "hello";
  10. char* str3 = "你好";
  11. printf("str3 = %s\n",str3);
  12. system("pause");
  13. }
 
指针变量占几个字节
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //32位环境下(硬件环境 操作系统环境 编译器的环境) 所有的指针变量 不管什么类型都占4个字节
  5. //地址线 32位 2^32 1byte 2^8 4个字节 刚好可以表示32位的二进制数
  6. //64位环境 指针变量长度 8字节
  7. main(){
  8. char* p ;
  9. int * p1;
  10. double* p2;
  11. printf("char类型指针占%d个字节\n",sizeof(p));
  12. printf("int类型指针占%d个字节\n",sizeof(p1));
  13. printf("double类型指针占%d个字节\n",sizeof(p2));
  15. system("pause");
  16. }
 技术分享

 

9.C的多级指针
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. main(){
  4. int i = 123;
  5. //一级指针 用来保存 普通变量的地址
  6. int* p = &i;
  7. //想保存一级指针的地址 使用二级指针 两个星
  8. int** p2 = &p;
  9. //想保存二级指针的地址 使用三级指针 三个星
  10. int*** p3 = &p2;
  12. ***p3 = 456;
  13. printf("i = %d\n",i);
  14. system("pause");
  15. }
 
技术分享
多级指针的练习
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //main函数获取子函数中临时变量的地址 子函数要修改mian函数中临时变量的值
  4. void function(int** q){
  5. int i = 123;
  6. *q = &i;
  7. printf("i的地址%#x\n", &i);
  8. }
  11. main(){
  12. //声明一个一级指针用来保存地址
  13. int* p;
  14. function(&p);
  15. printf("p的值%#x\n", p);
  16. system("pause");
  17. }
 
10.静态内存分配 动态内存分配
  ① 静态内存分配  栈内存  stack  c/java  大小固定  由系统统一管理分配和回收
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //java的数组 int array[] = new int[]{}; java的数组都在堆中
  4. //c的数组可以在栈里
  5. int* function1(){
  6. int array[] = {1,2,3,4,5};
  7. printf("array的地址%#x\n",&array);
  8. return &array;
  9. }
  11. int* function2(){
  12. int array1[] = {5,4,3,2,1};
  13. printf("array1的地址%#x\n",&array1);
  14. return &array1;
  15. }
  16. main(){
  17. int* p = function1();
  18. function2();
  19. printf("*(p+0)=%d,*(p+1)=%d,*(p+2)=%d\n",*(p+0),*(p+1),*(p+2));
  20. printf("*(p+0)=%d,*(p+1)=%d,*(p+2)=%d\n",*(p+0),*(p+1),*(p+2));
  21. system("pause");
  22. }
 
 ②动态内存分配  堆内存 heap
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //动态内存分配 操作的是堆内存(heap ) 堆内存 大小跟机器运行程序时的状态有关
  4. //java申请堆内存 new
  5. //c申请堆内存 malloc(堆内存的大小) 返回值 申请到的堆内存的首地址 memory allocation 内存分配
  6. //C申请的堆内存需要手动释放 free(p) 传入的参数就是malloc的返回值
  7. main(){
  8. int* p = malloc(sizeof(int)*5);
  9. //for循环c当中需要先声明变量 不能在for()直接声明
  10. int i;
  11. for(i = 0;i<5;i++){
  12. *(p+i) = i;
  13. }
  14. printf("*(p+0)=%d\n",*(p+0));
  15. printf("*(p+1)=%d\n",*(p+1));
  16. printf("*(p+2)=%d\n",*(p+2));
  17. printf("*(p+0)=%d\n",*(p+0));
  18. printf("*(p+1)=%d\n",*(p+1));
  19. printf("*(p+2)=%d\n",*(p+2));
  20. printf("*(p+0)=%d\n",*(p+0));
  21. printf("*(p+1)=%d\n",*(p+1));
  22. printf("*(p+2)=%d\n",*(p+2));
  23. //c需要手动释放申请的堆内存
  24. free(p);
  25. printf("*(p+0)=%d\n",*(p+0));
  26. printf("*(p+1)=%d\n",*(p+1));
  27. system("pause");
  28. }
 
练习 :学生学号管理系统
提示用户输入学生的人数 根据输入申请堆内存 用来保存学生的学号
提示用户输入学生的学号
来了插班生 申请新的内存用来保存新来学生的学号
提示用户输入新来学生的学号
回显所有学生的学号
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. //realloc re- alloc 在malloc函数的基础上 重新分配足够大的内存
  4. // realloc(malloc的返回值,一共要的申请内存大小) 返回申请到的足够大的内存首地址
  5. // 如果malloc 申请到的内存 后面还有足够大的空间供使用 这个时候 直接在malloc申请到的内存后 继续申请足够大的内存
  6. // 如果malloc 申请到的内存 后面没有足够大的空间供使用 这个时候 会开辟一块新的足够大的内存 并且把之前malloc 申请到的内存的
  7. //内容复制过来 释放之前malloc的内存
  8. main(){
  9. printf("请输入学生的人数:");
  10. int count;
  11. scanf("%d",&count);
  12. //申请足够大的堆内存 用来保存学生的学号
  13. int* p = malloc(sizeof(int)*count);
  14. int i;
  15. for(i = 0;i<count;i++){
  16. printf("请输入第%d个学生的学号:",(i+1));
  17. scanf("%d",p+i);
  18. }
  19. for(i = 0;i<count;i++){
  20. printf("第%d个学生的学号是%d\n",(i+1),*(p+i));
  21. }
  22. //来了插班生
  23. printf("请输入插班生的人数:");
  24. int newcomer;
  25. scanf("%d",&newcomer);
  26. //申请新的足够大的内存
  27. p = realloc(p,(newcomer+count)*sizeof(int));
  28. for(i = count;i<count+newcomer;i++){
  29. printf("请输入第%d个学生的学号:",(i+1));
  30. scanf("%d",p+i);
  31. }
  32. for(i = 0;i<count+newcomer;i++){
  33. printf("第%d个学生的学号是%d\n",(i+1),*(p+i));
  34. }
  35. system("pause");
  36. }
 
 
11.C的结构体 ☆☆☆☆☆
class Student{
 char gender;
   short age;
   int score;
}
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. /*
  4. class Student{
  5. char gender;
  6. short age;
  7. int score;
  9. void study(){
  10. System.out.println("好好学习");
  11. }
  12. }
  13. Student stu = new Student();
  14. stu.age;
  15. */
  16. struct Student{
  17. char gender; //1
  18. short age; //2
  19. int score; //4
  20. void(*study)();
  21. };
  23. void study(){
  24. printf("good good study,day day up!!!\n");
  25. }
  26. //函数指针的定义 返回值(*函数指针的名字)(形参类型)
  27. //结构体的大小 ① 大于或者等于所有成员的大小的和 ②是最大的成员的大小的整数倍
  28. //C结构体中只能有变量的声明 不能有函数 可以通过函数指针 让一个函数指针变量指向一个具体的函数 使结构体实现有函数的功能
  29. //结构体的指针
  30. main(){
  31. struct Student stu = {‘f‘,18,90,&study};
  32. //让学生study指针变量指向具体函数 需要注意指向的这个函数 返回值和形参得跟函数指针保持一致
  33. //stu.study = &study;
  34. stu.study();
  35. printf("学生的性别是%c\n",stu.gender);
  36. printf("学生的年龄是%hd\n",stu.age);
  37. //printf("学生的成绩是%d\n",stu.score);
  38. printf("学生结构体占%d个字节\n",sizeof(stu));
  40. struct Student* p = &stu;
  41. (*p).study();
  42. //间接引用运算符
  43. p->study();
  45. struct Student** p2 = &p;
  46. (**p2).study();
  47. (*p2)->study();
  49. system("pause");
  50. }
 
12.C的联合体
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. union un{
  4. short s;
  5. int i;
  6. }
  7. // ①联合体所有的成员 使用同一块内存
  8. //② 联合体的大小取决于最大的变量占的内存空间
  9. //③对联合体中的成员多次赋值 只有最后一次是有意义的 之前的赋值都会被覆盖
  10. main(){
  11. union un u;
  12. printf("union联合体占%d个字节\n",sizeof u);
  13. u.s = 1234;
  14. u.i = 12345678;
  15. printf("u.s = %hd\n",u.s);
  16. system("pause");
  17. }
 
13.C的枚举
  1. #include<stdlib.h>
  2. #include<stdio.h>
  3. enum Weekday{
  4. SUN,MON,TUE,WEND,THUR,FRI=8,SAT
  5. }
  6. //枚举 定义了当前类型的取值范围只能从枚举值中取值
  7. //默认枚举值从0开始 后面依次+1
  8. main(){
  9. enum Weekday day = SAT;
  10. printf("day = %d\n",day);
  12. system("pause");
  13. }
 
14.typedef 自定义类型

JNI_01


联系
我们