Explicação detalhada de palavras -chave nativas em Java

1. O que é o método nativo
Simplificando, um método nativo é uma interface na qual o Java chama o código não Java. Um método nativo é um método Java: a implementação deste método é implementada por um idioma que não é Java, como C. Esse recurso não é exclusivo do Java. Muitas outras linguagens de programação têm esse mecanismo. Por exemplo, no C ++, você pode usar o externo "C" para informar ao compilador C ++ para chamar uma função C.
"Um método nativo é um método Java cuja implementação é fornecida pelo código não Java".
Ao definir um método nativo, o órgão de implementação não é fornecido (alguns são como definir uma interface Java), porque seu órgão de implementação é implementado fora por um idioma não Java. , Aqui está um exemplo:

 pacote java.lang; classe pública objeto {...... public final native Class <?> getClass (); public nativo int hashcode (); Clone de objeto nativo protegido () lança clonenotsupportedException; public final Native Void notify (); public final nativo void notifyAll (); Public Final Native Void Wait (tempo limite longo) lança interruptedException; ......}

O nativo do identificador pode ser usado com todos os outros identificadores Java, exceto abstrato. Isso é razoável porque a nativa implica que esses métodos têm órgãos de implementação, mas esses órgãos de implementação não são Java, mas abstrato obviamente indica que esses métodos não têm órgãos de implementação. Quando os identificadores nativos e outros identificadores Java são usados, seu significado não é diferente do dos métodos não nativos.

Um método nativo pode retornar qualquer tipo Java, incluindo tipos não primitivos, e também pode executar o controle de exceção. A implementação desses métodos pode fazer uma exceção e jogá -lo, o que é muito semelhante ao método de Java.

A existência do método nativo não tem nenhum efeito em outras classes chamando esses métodos locais. De fato, outras classes que chamam esses métodos nem sabem que estão chamando um método local. A JVM controlará todos os detalhes de chamar o método local.

Se uma classe que contém um método local for herdada, a subclasse herdará o método local e pode reescrever o método em Java (isso parece um pouco estranho). Da mesma forma, se um método local for identificado por Fianl, ele não poderá ser reescrito depois de ser herdado.

Os métodos locais são muito úteis porque expandem efetivamente a JVM. De fato, o código Java que escrevemos usou métodos locais. Na implementação do mecanismo de concorrência Java (multi-threading) da Sun, muitos pontos de contato com o sistema operacional usam métodos locais, o que permite que os programas Java excedam os limites do tempo de execução do Java. Com os métodos locais, os programas Java podem executar quaisquer tarefas no nível do aplicativo.

2. Como usar

A palavra -chave nativa indica que seu método de modificação é um método original. A implementação correspondente do método não está no arquivo atual, mas nos arquivos implementados em outros idiomas (como C e C ++). O idioma Java em si não pode acessar e operar a camada subjacente do sistema operacional, mas pode usar a interface JNI para chamar outros idiomas para obter acesso à camada subjacente.

O JNI é uma interface nativa do Java, uma interface de programação nativa, que faz parte do Java Software Development Kit (SDK). O JNI permite que o código Java use as bases de código e código escritas em outros idiomas. A API de invocação (parte do JNI) pode ser usada para incorporar máquinas virtuais Java (JVMS) em aplicativos nativos, permitindo que os programadores ligue para o código Java de código nativo interno.

No entanto, as chamadas para Java externo geralmente não podem ser portadas para outras plataformas, e as exceções de segurança também podem ser aumentadas em applets. A implementação do código nativo impedirá que seu aplicativo Java passe 100% de teste Java puro. No entanto, se uma chamada local deve ser realizada, existem várias diretrizes a serem consideradas:

1. Encapsula todos os seus métodos locais em uma classe que chama uma única DLL. Para cada plataforma de sistema operacional de destino, uma versão da DLL específica para a plataforma apropriada pode ser usada. Isso minimiza o impacto do código local e ajuda a levar em consideração os problemas de portas necessários posteriormente.

2. O método local é o mais simples possível. Tente minimizar a dependência do seu método local em DLLs de tempo de execução de terceiros (incluindo a Microsoft). Torne seu método local o mais independente possível para minimizar a sobrecarga necessária para carregar sua DLL e aplicação. Se uma DLL de tempo de execução for necessária, deve ser fornecida com o aplicativo.

As etapas de escrita do JNI são as seguintes:

• um. Escreva uma aula de Java com um método com uma declaração nativa
• b. Compilar e compilar as classes Java usando o comando javac
• c. Use java -jni **** para gerar um arquivo de cabeçalho com o nome do sufixo .h
• d. Implementar métodos locais usando outros idiomas (C, C ++)
• e. Gerar uma biblioteca de link dinâmica para arquivos escritos por métodos locais

Aqui está um exemplo simples de chamar um programa C local em Java:

um. Escreva a classe Helloworld.java

 classe helloworld {public nativo void hello (); static {System.loadLibrary ("hello");} public static void main (string [] args) {new Helloworld (). hello ();}}

b. Tradução

javac helloworld.java

c. Gerar arquivo .h

Javah -Jni Helloworld

O conteúdo gerado é o seguinte:

 /* Não edite este arquivo - é a máquina gerada*/#inclua <jni.h>/* cabeçalho para a classe helloworld*/#ifndef _included_helloworld#define _included_helloworld#ifdef __cplusplusextern "c" {#endif/** Class. Jnicall java_helloworld_hello (jnienv *, jobject);#ifdef __cplusplus}#endif#endif

O primeiro parâmetro é o ponteiro do ambiente JNI usado ao chamar o método JNI. O segundo parâmetro é um identificador para o objeto Java Helloworld instanciado neste código Java. Outros parâmetros são parâmetros do próprio método

Implementação de DC

 #include <ni.h> #include "helloworld.h" #include <stdo.h> jniexport void jnicall java_helloworld_hello (jnienv *Env, Jobject obj) {printf ("Hello World!/n"); retorno;}

Entre eles, a primeira linha é introduzir o arquivo jni.h (no %java_home %/incluir diretório), que contém as definições de jnienv e jobject.

e. Compilar a implementação C.

Aqui, tomando o Windows como exemplo, você precisa gerar um arquivo DLL. Sob a pasta salvar helloworldimpl.c, use o compilador VC para criá -lo.

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

NOTA: O nome do arquivo DLL gerado está configurado após a opção -Fe, aqui está olá, porque o nome que usamos quando o arquivo loadlibary no arquivo helloworld.java é hello. Obviamente, após a modificação aqui, ele também precisa ser modificado lá. Além disso, o parâmetro -i%java_home%/inclui -i%java_home%/incluir/win32 precisa ser adicionado, porque o arquivo jni.h é introduzido ao escrever o método local na quarta etapa.

f. Execute o programa

Java Helloworld está ok!

O exposto acima é uma introdução detalhada às palavras -chave nativas em Java, e espero que seja útil para o aprendizado de todos.