CodeBlanks Logo Icon CodeBlanks
Login Register

C/C++ implementation

Learn JNI implementation with C/C++.

JNI type mapping

JNI represents Java types with signature letters on the C side: int → I, long → J, boolean → Z, void → V, String → Ljava/lang/String;. A method signature has the form (params)return.

For example, int sum(int a, int b) has the signature (II)I. These signatures are visible with javap -s and are appended to the C function name for overloading.

Loading the native library

Before a native method is called the native library must be loaded: System.loadLibrary("nativeops");. This call is usually placed in a static block so the library is ready when the class loads. The library is searched along java.library.path.

If the library is not found an UnsatisfiedLinkError is thrown. Cross-platform projects build a separate library for each operating system.

Practice Write the type mapper and native class

Define class TypeMapper with a static String jni(String t) method that uses a switch to return int → "I", long → "J", boolean → "Z", void → "V". Define class NativeOps with native int sum(int a, int b); and a static block calling System.loadLibrary("nativeops"); (wrapped in try). In main print System.out.println("(" + TypeMapper.jni("int") + TypeMapper.jni("int") + ")" + TypeMapper.jni("int"));.

Starter code

Main.java
// Define the TypeMapper class: static String jni(String t) returns I/J/Z/V via switch
// Define the NativeOps class: native int sum(int a, int b) and a static block with System.loadLibrary

// main: print the (II)I signature

Sample solution

Main.java
class TypeMapper {
    static String jni(String t) {
        return switch (t) {
            case "int" -> "I";
            case "long" -> "J";
            case "boolean" -> "Z";
            case "void" -> "V";
            default -> "?";
        };
    }
}

class NativeOps {
    native int sum(int a, int b);
    static {
        try { System.loadLibrary("nativeops"); } catch (UnsatisfiedLinkError e) { }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("(" + TypeMapper.jni("int") + TypeMapper.jni("int") + ")" + TypeMapper.jni("int"));
    }
}

Expected output

(II)I

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What is the JNI signature letter of int?

  • I Correct answer
  • J
  • Z
  • L

Explanation: int is shown with the letter I in JNI signatures.

2 Complete the method signature

Question 
String sig = "(____";
Answer 
String sig = "(II)I";

Explanation: The signature (II)I means int sum(int, int).

3 Match the type mapping

Term Meaning
int I
long J
boolean Z
String Ljava/lang/String;

All lessons in Expert

1 JVM internals

  1. JVM architecture
  2. Class loaders
  3. Bytecode
  4. JIT compiler
  5. Runtime data areas
  6. Summary - JVM internals

2 Memory model

  1. Heap and stack
  2. happens-before
  3. volatile
  4. final field guarantees
  5. Metaspace
  6. Summary - Memory model

3 NIO

  1. Buffer
  2. Channel
  3. Selector
  4. Charset
  5. Path and Files (NIO.2)
  6. Summary - NIO

4 Reactive

  1. Flow API
  2. Publisher and Subscriber
  3. SubmissionPublisher
  4. Backpressure
  5. Project Reactor Mono
  6. Summary - Reactive

5 JNI

  1. native methods
  2. javah and headers
  3. JNIEnv
  4. C/C++ implementation
  5. Foreign Function & Memory API
  6. Summary - JNI

6 Performance and GC

  1. JMH
  2. JFR and jcmd
  3. GC tuning
  4. Heap dump
  5. JIT tuning
  6. Summary - Performance and GC

7 Bytecode (ASM)

  1. Project design
  2. ClassReader
  3. ClassVisitor
  4. Bytecode transformation
  5. Putting it together

8 Expert final

  1. Project design
  2. Reactive layer
  3. Performance layer
  4. Microservice basics
  5. Putting it together