1. Declaring a Native Method in a Java Class#

In Java, use the native keyword to declare a method:

1
package org.example;
2

3
public class Main {
4
    public static native void accessNative();
5

6
    public static void main(String[] args) {
7
        // Load the DLL (Windows) or .so (Linux/macOS) using the full path
8
        System.load("C:/full/path/to/org_example_Main.dll");  // Change to the actual path
9
        accessNative();
10
    }
11
}

2. Generating Header Files Using javac -h#

Run the following command in the terminal to generate the .h header files:

1
javac -h . src/org/example/Main.java

🔧 The option -h . specifies that the .h files will be output to the current directory.

3. Creating and Implementing the C Source File#

Create a .c source file, for example org_example_Main.c, and copy the corresponding function declarations from the .h header file generated earlier by javac -h.

For example, in org_example_Main.h you might see:

1
/*
2
 * Class:     org_example_Main
3
 * Method:    accessNative
4
 * Signature: ()V
5
 */
6
JNIEXPORT void JNICALL Java_org_example_Main_accessNative
7
  (JNIEnv *, jclass);

Please copy this snippet into your .c file and add parameter names (otherwise it won’t compile):

1
#include <jni.h>
2
#include "org_example_Main.h"
3

4
JNIEXPORT void JNICALL Java_org_example_Main_accessNative
5
  (JNIEnv *env, jclass clazz) {
6
    // Native logic is implemented here
7
    return;
8
}

💡 Tip:

• JNIEnv *env is the environment pointer provided by JNI, used to call Java methods, access fields, and more.
• jclass clazz represents the calling class parameter for static methods; for instance methods, it is jobject obj.

4. Compiling to a Shared Library (DLL / SO) Using GCC#

Use the appropriate command depending on your operating system:

1
gcc -I"%JAVA_HOME%\include" ^
2
    -I"%JAVA_HOME%\include\win32" ^
3
    -shared -o org_example_Main.dll org_example_Main.c

1
gcc -I"$JAVA_HOME/include" \
2
    -I"$JAVA_HOME/include/linux" \
3
    -fPIC -shared -o org_example_Main.so org_example_Main.c

1
gcc -I"$JAVA_HOME/include" \
2
    -I"$JAVA_HOME/include/darwin" \
3
    -fPIC -dynamiclib -o org_example_Main.dylib org_example_Main.c

🧯 Error Encountered: Can’t load this .dll (machine code=0x14c)…#

If you encounter the following error when running Java:

1
Can't load this .dll (machine code=0x14c) on a AMD 64-bit platform

This means the DLL you compiled is 32-bit (x86), while your JVM is 64-bit (x64), or vice versa.

✅ Please use the following command to check which architecture your gcc is:

1
gcc -dumpmachine

You should see output like this:

1
x86_64-w64-mingw32   ← indicates 64-bit

If you see something like this:

1
mingw32     ← indicates 32-bit ❌

It means you are using the wrong architecture compiler and should switch to the 64-bit version.

✅ Solution#

You can use MSYS2 to install the 64-bit MinGW:

1
pacman -S mingw-w64-ucrt-x86_64-gcc

Then open the MSYS2 MinGW 64-bit terminal (or add the ucrt-x86_64-gcc directory to your environment variables), and recompile your C file into a 64-bit .dll using the gcc in that environment:

1
gcc -I"$JAVA_HOME/include" \
2
    -I"$JAVA_HOME/include/win32" \
3
    -shared -o org_example_Main.dll org_example_Main.c

✅ Make sure the DLL architecture matches the JVM architecture to load and run smoothly!