tarjeta - ¿Para qué es la palabra clave nativa en Java?

tarjeta mastercard banco nacion (11)

Mientras jugaba este rompecabezas (es un juego de preguntas clave de Java), me topé con la palabra clave native .

¿Para qué se utiliza la palabra clave nativa en Java?

Como respondió SLaks, la palabra clave native es para llamar código nativo.

También fue utilizado por GWT para implementar métodos javascript.

Directamente desde la especificación del lenguaje Java :

Un método que es native se implementa en código dependiente de la plataforma, normalmente escrito en otro lenguaje de programación como C, C ++, FORTRAN o lenguaje ensamblador. El cuerpo de un método native se da solo como un punto y coma, lo que indica que se omite la implementación, en lugar de un bloque.

La palabra clave native se aplica a un método para indicar que el método se implementa en código nativo utilizando JNI (Interfaz nativa de Java).

La palabra clave nativa se aplica a un método para indicar que el método se implementa en código nativo utilizando JNI (Interfaz nativa de Java) . Native es un modificador aplicable solo para métodos y no podemos aplicarlo en ningún otro lugar . Los métodos que se implementan en C, C ++ se denominan métodos nativos o métodos externos.

El objetivo principal de las palabras clave nativas son:

Para mejorar el rendimiento del sistema.
Para lograr la comunicación nivel de misión / nivel de memoria.
Para utilizar el código existente no existente de Java.

La palabra clave nativa se utiliza para declarar un método que se implementa en código dependiente de la plataforma, como C o C ++. Cuando un método está marcado como nativo, no puede tener un cuerpo y debe terminar con un punto y coma en su lugar. La especificación de la interfaz nativa de Java (JNI) rige las reglas y pautas para implementar métodos nativos, como la conversión de tipos de datos entre Java y la aplicación nativa.

El siguiente ejemplo muestra una clase con un método declarado como nativo:

public class NativeExample { public native void fastCopyFile(String sourceFile, String destFile); }

Las funciones que implementan código nativo son declaradas nativas.

La interfaz nativa de Java (JNI) es un marco de programación que permite que el código Java que se ejecuta en una máquina virtual de Java (JVM) llame y sea llamado por aplicaciones nativas (programas específicos para una plataforma de sistema operativo y hardware) y bibliotecas escritas en Otros lenguajes como C, C ++ y ensamblaje.

http://en.wikipedia.org/wiki/Java_Native_Interface

Marca un método, que se implementará en otros lenguajes, no en Java. Funciona junto con JNI (Java Native Interface).

Los métodos nativos se utilizaron en el pasado para escribir secciones críticas de rendimiento, pero con Java cada vez más rápido, ahora esto es menos común. Actualmente se necesitan métodos nativos cuando

Necesita llamar a una biblioteca de Java que está escrita en otro idioma.
Debe acceder a los recursos del sistema o hardware que solo son accesibles desde el otro idioma (normalmente C). En realidad, muchas funciones del sistema que interactúan con una computadora real (por ejemplo, el disco y la E / S de red) solo pueden hacer esto porque llaman código nativo.

Vea también Especificación de la interfaz nativa de Java

NATIVE is Non access modifier.it se puede aplicar solo a METHOD. Indica la implementación del método o código PLATFORM-DEPENDENT.

Native es una palabra clave en java, que se usa para hacer una estructura no implementada (método) como abstracta, pero sería una plataforma dependiente como el código nativo y se ejecutaría desde la pila nativa no desde la pila java.

Ejemplo mínimo para aclarar las cosas:

Main.java :

public class Main { public native int square(int i); public static void main(String[] args) { System.loadLibrary("Main"); System.out.println(new Main().square(2)); } }

Main.c :

#include <jni.h> #include "Main.h" JNIEXPORT jint JNICALL Java_Main_square( JNIEnv *env, jobject obj, jint i) { return i * i; }

Compilar y ejecutar :

sudo apt-get install build-essential openjdk-7-jdk export JAVA_HOME=''/usr/lib/jvm/java-7-openjdk-amd64'' javac Main.java javah -jni Main gcc -shared -fpic -o libMain.so -I${JAVA_HOME}/include / -I${JAVA_HOME}/include/linux Main.c java -Djava.library.path=. Main

Salida :

4

Probado en Ubuntu 14.04 AMD64. También trabajó con Oracle JDK 1.8.0_45.

Ejemplo en GitHub para que juegues.

Los guiones bajos en los nombres de paquetes / archivos de Java se deben _1 con _1 en el nombre de la función C como se menciona en: Invocar funciones JNI en el nombre del paquete de Android que contiene un guión bajo

Interpretación :

Te permite:

llamar a una biblioteca compilada dinámicamente (aquí escrita en C) con código de ensamblaje arbitrario de Java
y obtener resultados de nuevo en Java

Esto podría ser usado para:

escriba código más rápido en una sección crítica con mejores instrucciones de ensamblaje de la CPU (no CPU portátil)
Hacer llamadas directas al sistema (no OS portátil)

con la compensación de menor portabilidad.

También es posible que llame a Java desde C, pero primero debe crear una JVM en C: ¿Cómo llamar a las funciones Java desde C ++?

Android NDK

El concepto es exactamente el mismo en este contexto, excepto que tiene que usar la plantilla de Android para configurarlo.

El repositorio oficial de NDK contiene ejemplos "canónicos", como la aplicación hello-jni:

Al unzip un .apk con NDK en Android O, puede ver el .so precompilado que corresponde al código nativo en lib/arm64-v8a/libnative-lib.so .

TODO confirma: además, el file /data/app/com.android.appname-*/oat/arm64/base.odex , dice que es una biblioteca compartida, que creo que es el .dex precompilado de AOT correspondiente a los archivos Java en ART. Ver también: ¿Qué son los archivos ODEX en Android? ¿Entonces tal vez el Java también se ejecuta a través de una interfaz native ?

Ejemplo en el OpenJDK 8

Busquemos encontrar dónde está definido Object#clone en jdk8u60-b27.

Llegaremos a la conclusión de que se implementa con una llamada native .

Primero encontramos:

find . -name Object.java

lo que nos lleva a jdk/src/share/classes/java/lang/Object.java#l212 :

protected native Object clone() throws CloneNotSupportedException;

Ahora viene la parte difícil, encontrar dónde está el clon en medio de toda la indirección. La consulta que me ayudó fue:

find . -iname object.c

que encontraría archivos C o C ++ que podrían implementar métodos nativos de Object. Nos lleva a jdk/share/native/java/lang/Object.c#l47 :

static JNINativeMethod methods[] = { ... {"clone", "()Ljava/lang/Object;", (void *)&JVM_Clone}, }; JNIEXPORT void JNICALL Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls) { (*env)->RegisterNatives(env, cls, methods, sizeof(methods)/sizeof(methods[0])); }

lo que nos lleva al símbolo JVM_Clone :

grep -R JVM_Clone

lo que nos lleva a hotspot/src/share/vm/prims/jvm.cpp#l580 :

JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle)) JVMWrapper("JVM_Clone");

Después de expandir un montón de macros, llegamos a la conclusión de que este es el punto de definición.

native es una palabra clave en java, indica que depende de la plataforma.
native métodos native actúan como interfaz entre Java ( JNI ) y otros lenguajes de programación.