Thanks :http://www.iam.ubc.ca/guides/javatut99/native1.1/stepbystep/step1.html
Step 1: Write the Java Code
The following Javacode segment defines a class named HelloWorld
. This class declares one native method, implements a main method, and has a static code segment.
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary("hello");
}
public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}
Declare a Native Method
You must declare all methods, whether Java methods or native methods, within a class on the Java side. When you write a method implementation in a language other than Java, you must include the keywordnative
as part of the method's definition within the Java class. Thenative
keyword signals to the Java compiler that the function is a native language function. It is easy to tell that the implementation for theHelloWorld
class'sdisplayHelloWorld
method is written in another programming language because thenative
keyword appears as part of its method definition:This native method declaration in your Java class provides only the method signature forpublic native void displayHelloWorld();
displayHelloWorld
. It provides no implementation for the method. You must provide the implementation fordisplayHelloWorld
in a separate native language source file.The method declaration for
displayHelloWorld
also indicates that the method is a public instance method, accepts no arguments, and returns no value. For more information about arguments to and return values from native methods see Interacting with Java from the Native Side.
Load the Library
You compile the native language code that implementsdisplayHelloWorld
into a shared library (you will do this in Step 5: Create a Shared Library ). The runtime system later loads the shared library into the Java class that requires it. Loading the library into the Java class maps the implementation of the native method to its declaration.The
HelloWorld
class uses theSystem.loadLibrary
method. TheSystem.loadLibrary
method loads the shared library that will be created when you compile the implementation code. Place this method within a static initializer. The argument toSystem.loadLibrary
is the shared library name. This can be any name that you choose. The system uses a standard, but platform-specific, approach to convert the library name to a native library name. For example, the Solaris system converts the library name "hello" tolibhello.so
, while a Win32 system converts the same name tohello.dll
.The following static initializer from the
HelloWorld
class loads the appropriate library, namedhello
. The runtime system executes a class's static initializer when it loads the class.static {
System.loadLibrary("hello");
}
Write the Main Method
The HelloWorld
class, because it is an application, also includes a main
method to instantiate the class and call the native method. The main
method instantiates HelloWorld
and calls the displayHelloWorld
native method.
public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
You can see from the code sample that you call a native method in the same manner as you call a regular method: just append the name of the method to the end of the object name, separated with a period ('.'). A matched set of parentheses, (), follow the method name and enclose any arguments to pass into the method. The displayHelloWorld
method doesn't take any arguments.