Step By Step |
The following Java code segment defines a class namedHelloWorld
. This class has one method and a static code segment.class HelloWorld { public native void displayHelloWorld(); static { System.loadLibrary("hello"); } }Define a Native Method
You must define all methods, whether Java methods or native methods, within a Java class. When you write a method in a programming 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. You can tell that the implementation for theHelloWorld
class'sdisplayHelloWorld()
method is written in another programming language because of thenative
keyword that appears as part of its method definition:This method definition in your Java class provides only the method signature forpublic native void displayHelloWorld();displayHelloWorld()
. It provides no implementation for the method. The implementation fordisplayHelloWorld()
is provided in a separate native language source file.The method definition 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 Java Native Interface Programming.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) and you also load it into the Java class that requires it. Loading the library into the Java class maps the implementation of the native method to its definition.Use the
System.loadLibrary
method to load the shared library created when you compiled 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"); }Create the Main Program
You must also create a separate source file with a Java application that instantiates the class that contains the native method definition. This Java application will also call the native method. Because this is an application, it must have amain
function. In a separate source file, which for this example we will name Main.java, create a Java application that instantiatesHelloWorld
and calls thedisplayHelloWorld()
native method.You can see from the code sample above 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, ( and ), follow the method name and enclose any arguments to pass into the method. Theclass Main { public static void main(String[] args) { new HelloWorld().displayHelloWorld(); } }displayHelloWorld()
method doesn't take any arguments.
Step By Step |