Specify the native keyword in Java

package java.lang; 
public class Object { 
  ......
  public final native Class<?> getClass(); 
  public native int hashCode(); 
  protected native Object clone() throws CloneNotSupportedException; 
  public final native void notify(); 
  public final native void notifyAll(); 
  public final native void wait(long timeout) throws InterruptedException; 
  ......
} 

The identifier native can be used with all other java identifiers, except abstract. This makes sense, because native implies that these methods have implementors that are not java, while abstract clearly indicates that these methods have no implementors. When native is used with other java identifiers, its meaning is no different from that of non-Native Method.

An native method method can return any java type, including non-basic types, and can also be used for exception control. Implementations of these methods can make an exception and throw it, much like java's method.

The presence of native method does not have any effect on other classes calling these local methods, and in fact the other classes calling these methods do not even know that it is calling a local method. JVM will control all the details of calling local methods.

If a class with a local method is inherited, the subclass inherits the local method and can override the method in java language (this seems odd). Likewise, if a local method is identified by fianl, it cannot be overridden after inheritance.

The local method is useful because it effectively extends jvm. In fact, the java code we wrote already USES local methods, and in sun's concurrent (multithreaded) java implementation, many of the points of contact with the operating system use local methods, allowing java programs to transcend java runtime boundaries. With local methods, the java program can do any application-level task.

ii. Method of use

The native keyword states that the method it modifies is a primitive method that corresponds to an implementation not in the current file but in a file implemented in other languages such as C and C++. The Java language itself cannot access and manipulate the underlying operating system, but it can be accessed by calling other languages through the JNI interface.

JNI is the Java native interface (Java Native Interface), a native programming interface that is part of the Java software development toolkit (Java Software Development Kit, SDK). JNI allows Java code to use code and code bases written in other languages. Invocation API (part of JNI) can be used to embed Java virtual machines (JVM) into native applications, allowing programmers to call Java code from within native code.

However, calls to the outside of Java are generally not portable to other platforms, and security exceptions can be thrown in applet. Implementing native code will prevent your Java application from passing the 100% Java test. However, if you must make a local call, consider a few guidelines:

1. Encapsulate all your local methods into a class that invokes a single DLL. For each target operating system platform, the appropriate platform-specific version of DLL can be used. This minimizes the impact of native code and helps to take into account future migration needs.

2. Keep local methods simple. Try to minimize the dependency of your local methods on the DLL runtime of third parties (including Microsoft). Keep your local methods as independent as possible to minimize the overhead of loading your DLL and applications. If the runtime DLL is required, it must be provided with the application.

The steps to write JNI are as follows:

class HelloWorld{

public native void hello();

static{
System.loadLibrary("hello");
}

public static void main(String[] args){

new HelloWorld().hello();
}

}

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: HelloWorld
* Method: hello
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloWorld_hello
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

#include <jni.h>
#include "HelloWorld.h"
#include <stdio.h>
JNIEXPORT void JNICALL Java_HelloWorld_hello(JNIEnv *env,jobject obj){
printf("Hello World!\n");
return;
}