The Java Native Keyword and Methods

1. Overview

In this quick tutorial, we’ll discuss the concept of the native keyword in Java, and we’ll also show how to integrate native methods into Java code.

2. The native Keyword in Java

First of all, let’s discuss what is a native keyword in Java.

Simply put, this is a non-access modifier that is used to access methods implemented in a language other than Java like C/C++.

It indicates platform-dependent implementation of a method or code and also acts as an interface between JNI and other programming languages.

3. native Methods

A native method is a Java method (either an instance method or a class method) whose implementation is also written in another programming language such as C/C++.

Moreover, a method marked as native cannot have a body and should end with a semicolon:

[ public | protected | private] [return_type] native method ();

We can use them to:

• implement an interface with system calls or libraries written in other programming languages
• access system or hardware resources that are only reachable from the other language
• integrate already existing legacy code written in C/C++ into a Java application
• call a compiled dynamically loaded library with arbitrary code from Java

4. Examples

Let’s now demonstrate how to integrate these methods into our Java code.

4.1. Accessing Native Code in Java

First of all, let’s create a class DateTimeUtils that needs to access a platform-dependent native method named getSystemTime:

public class DateTimeUtils {
    public native String getSystemTime();
    // ...
}

To load it, we’ll use the System.loadLibrary.

Let’s place the call to load this library in a static block so that it is available in our class:

public class DateTimeUtils {
    public native String getSystemTime();

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

We have created a dynamic-link library, nativedatetimeutils, that implements getSystemTime in C++ using detailed instructions covered in our guide to JNI article.

4.2. Testing native Methods

Finally, let’s see how we can test native methods defined in the DateTimeUtils class:

public class DateTimeUtilsManualTest {

   @BeforeClass
    public static void setUpClass() {
        // .. load other dependent libraries  
        System.loadLibrary("nativedatetimeutils");
    }

    @Test
    public void givenNativeLibsLoaded_thenNativeMethodIsAccessible() {
        DateTimeUtils dateTimeUtils = new DateTimeUtils();
        LOG.info("System time is : " + dateTimeUtils.getSystemTime());
        assertNotNull(dateTimeUtils.getSystemTime());
    }
}

Below is the output of the logger:

[main] INFO  c.b.n.DateTimeUtilsManualTest - System time is : Wed Dec 19 11:34:02 2018

As we can see, with the help of the native keyword, we’re successfully able to access a platform-dependent implementation written in another language (in our case C++).

5. Conclusion

In this article, we’ve learned the basics of native keywords and methods. With a quick example, we’ve also learned how to integrate them in Java.

The code snippets used in this article are available over Github.