Explicación detallada de las palabras clave nativas en Java

1. ¿Qué es el método nativo?
En pocas palabras, un método nativo es una interfaz en la que Java llama código no Java. Un método nativo es un método Java: la implementación de este método es implementada por un lenguaje no java, como C. Esta característica no es exclusiva de Java. Muchos otros lenguajes de programación tienen este mecanismo. Por ejemplo, en C ++, puede usar "C" externo para decirle al compilador C ++ que llame a una función C.
"Un método nativo es un método Java cuya implementación es proporcionada por el código no Java".
Al definir un método nativo, no se proporciona el cuerpo de implementación (algunos son como definir una interfaz Java), porque su cuerpo de implementación es implementado fuera de un lenguaje que no es Java. , Aquí hay un ejemplo:

 paquete java.lang; Objeto de clase pública {...... public Final Native Class <?> getClass (); público nativo int hashcode (); Objeto nativo protegido Clone () arroja clonenotsupportedException; Público Final Native Void notify (); Público Final Native NOVOVE NotifyAll (); Public Final Native Void Wait (Tiempo de espera largo) lanza interruptedException; ......}

El identificador nativo se puede usar con todos los demás identificadores de Java, excepto abstracto. Esto es razonable porque el nativo implica que estos métodos tienen cuerpos de implementación, pero estos organismos de implementación no son java, pero el abstracto obviamente indica que estos métodos no tienen cuerpos de implementación. Cuando se usan identificadores nativos y otros Java, su significado no es diferente al de los métodos no nativos.

Un método de método nativo puede devolver cualquier tipo de Java, incluidos los tipos no propensivos, y también puede realizar un control de excepción. La implementación de estos métodos puede hacer una excepción y lanzarla, que es muy similar al método de Java.

La existencia del método nativo no tiene ningún efecto en otras clases que llamen a estos métodos locales. De hecho, otras clases que llaman a estos métodos ni siquiera saben que está llamando a un método local. El JVM controlará todos los detalles de llamar al método local.

Si se hereda una clase que contiene un método local, la subclase heredará el método local y puede reescribir el método en Java (esto parece un poco extraño). Del mismo modo, si Fianl identifica un método local, no puede reescribirse después de que se herede.

Los métodos locales son muy útiles porque expanden efectivamente JVM. De hecho, el código Java que escribimos ha utilizado métodos locales. En la implementación del mecanismo de concurrencia Java (múltiples subprocesos) de Sun, muchos puntos de contacto con el sistema operativo usan métodos locales, lo que permite a los programas Java superar los límites del tiempo de ejecución de Java. Con los métodos locales, los programas Java pueden hacer tareas de nivel de aplicación.

2. Cómo usar

La palabra clave nativa indica que su método de modificación es un método original. La implementación correspondiente del método no está en el archivo actual, sino en los archivos implementados en otros idiomas (como C y C ++). El lenguaje Java en sí no puede acceder y operar la capa subyacente del sistema operativo, pero puede usar la interfaz JNI para llamar a otros idiomas para lograr el acceso a la capa subyacente.

JNI es una interfaz nativa de Java, una interfaz de programación nativa, que forma parte del Kit de desarrollo de software Java (SDK). JNI permite que el código Java use el código y las bases de código escritas en otros idiomas. La API de invocación (parte de JNI) se puede usar para incrustar las máquinas virtuales de Java (JVMS) en aplicaciones nativas, lo que permite a los programadores llamar al código Java desde el código nativo del interior.

Sin embargo, las llamadas a Java externa generalmente no pueden portarse a otras plataformas, y también se pueden aumentar las excepciones de seguridad en los applets. La implementación del código nativo evitará que su aplicación Java pase pruebas de Java 100% puras. Sin embargo, si se debe realizar una llamada local, hay varias pautas a considerar:

1. Encapsula todos sus métodos locales en una clase que llama a una sola DLL. Para cada plataforma de sistema operativo objetivo, se puede utilizar una versión de la DLL específica para la plataforma apropiada. Esto minimiza el impacto del código local y ayuda a tener en cuenta los problemas de portada requeridos más adelante.

2. El método local es lo más simple posible. Intente minimizar la dependencia de su método local en las DLL de tiempo de ejecución de terceros (incluida Microsoft). Haga que su método local sea lo más independiente posible para minimizar la sobrecarga requerida para cargar su DLL y la aplicación. Si se requiere una DLL de tiempo de ejecución, debe proporcionar la aplicación.

Los pasos de escritura de JNI son los siguientes:

• a. Escribe una clase de Java con un método con una declaración nativa
• b. Compilar y compilar clases de Java usando el comando Javac
• do. Use java -jni **** para generar un archivo de encabezado con el nombre de sufijo .h
• d. Implementar métodos locales utilizando otros idiomas (C, C ++)
• mi. Genere una biblioteca de enlaces dinámicos para archivos escritos por métodos locales

Aquí hay un ejemplo simple de llamar a un programa C local en Java:

a. Escribir clase Helloworld.java

 class Helloworld {public nation void hello (); static {System.LoadLibrary ("Hello");} public static void main (string [] args) {new HelloWorld (). Hello ();}}

b. Traducción

javac helloworld.java

do. Generar el archivo .h

javah -jni helloworld

El contenido generado es el siguiente:

 /* No edite este archivo: se genera la máquina*/#include <jni.h>/* encabezado para class helloworld*/#ifndef _included_helloworld#define _included_hellowlorld#ifdef __cplusextern "c" {#endif/** class: Helloworld* Method: Hello* Signature: () v* Jnie Jnicall java_helloworld_hello (jnienv *, jobject);#ifdef __cplusplus}#endif#endif

El primer parámetro es el puntero de entorno JNI utilizado al llamar al método JNI. El segundo parámetro es un mango del objeto Java Helloworld instanciado en este código Java. Otros parámetros son los parámetros del método en sí

Implementación de DC

 #include <jni.h> #include "helloworld.h" #include <stdio.h> jniexport void jnicall java_helloworld_hello (jnienv *env, jobject obj) {printf ("hola world!/n"); return;}

Entre ellos, la primera línea es introducir el archivo jni.h (en el directorio %java_home %/incluido), que contiene las definiciones de JNienv y Jobject.

mi. Compilar la implementación C

Aquí, tomando Windows como ejemplo, debe generar un archivo DLL. Debajo de la carpeta Guard HelloWorldimpl.c, use el compilador VC para crearlo.

cl -i%java_home%/include -i%java_home%/include/win32 -ld helloworldimp.c -fehello.dll

Nota: El nombre del archivo DLL generado se configura después de la opción, aquí está hola, porque el nombre que usamos cuando loadLibary en el archivo helloworld.java es hola. Por supuesto, después de la modificación aquí, también debe modificarse allí. Además, se debe agregar el parámetro -i%java_home%/include -i%java_home%/include/win32, porque el archivo jni.h se introduce al escribir el método local en el cuarto paso.

F. Ejecutar el programa

¡Java Helloworld está bien!

Lo anterior es una introducción detallada a las palabras clave nativas en Java, y espero que sea útil para el aprendizaje de todos.