UbuntuLinux

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

http://java.sun.com/docs/books/jni/html/intro.html#1811

The Java Native Interface (JNI) is a programming framework that allows Java code running in a Java Virtual Machine (JVM) to call and to be called^[1]hardware and operating system platform) and libraries written in other languages, such as C, C++ and assembly.

JNI allows one to write native methods to handle situations when an
application cannot be written entirely in the Java programming language
e.g. when the standard Java class library
does not support the platform-specific features or program library. It
is also used to modify an existing application, written in another
programming language, to be accessible to Java applications. Many of
the standard library classes depend on JNI to provide functionality to
the developer and the user, e.g. I/O file reading and sound
capabilities. Including performance- and platform-sensitive API
implementations in the standard library allows all Java applications to
access this functionality in a safe and platform-independent manner.
Before resorting to using JNI, developers should make sure the
functionality is not already provided in the standard libraries.

The JNI framework lets a native method utilize Java objects
in the same way that Java code uses these objects. A native method can
create Java objects and then inspect and use these objects to perform
its tasks. A native method can also inspect and use objects created by
Java application code.

JNI is sometimes referred to as the "escape hatch" for Java
developers because it allows them to add functionality to their Java
application that the standard Java APIs cannot otherwise provide. It
can be used to interface with code written in other languages, such as
C and C++. It is also used for time-critical calculations or operations
like solving complicated mathematical equations, since native code can
be faster than JVM code.

The JNI is designed to handle situations where you need to combine
Java applications with native code. As a two-way interface, the JNI can
support two types of native code: native libraries and native applications.

• You can use the JNI to write native methods
  that allow Java applications to call functions implemented in native
  libraries. Java applications call native methods in the same way that
  they call methods implemented in the Java programming language. Behind
  the scenes, however, native methods are implemented in another language
  and reside in native libraries.
  


• The JNI supports an invocation interface
  that allows you to embed a Java virtual machine implementation into
  native applications. Native applications can link with a native library
  that implements the Java virtual machine, and then use the invocation
  interface to execute software components written in the Java
  programming language. For example, a web browser written in C can
  execute downloaded applets in an embedded Java virtual machine
  implemention.
  

Remember that once an application uses the JNI, it risks losing two benefits of the Java platform.

First, Java applications that depend on the
JNI can no longer readily run on multiple host environments. Even
though the part of an application written in the Java programming
language is portable to multiple host environments, it will be
necessary to recompile the part of the application written in native
programming languages.

Second, while the Java programming language
is type-safe and secure, native languages such as C or C++ are not. As
a result, you must use extra care when writing applications using the
JNI. A misbehaving native method can corrupt the entire application.
For this reason Java applications are subject to security checks before
invoking JNI features.

As a general rule, you should architect the
application so that native methods are defined in as few classes as
possible. This entails a cleaner isolation between native code and the
rest of the application.