Java Native Interface (JNI) in depth

Learn how to install the C++ plugin for Apache NetBeans 13 to enable JNI development, including repository changes, and using JDK 8 for setup before building with newer JDKs.

Install Apache NetBeans 13 on Windows, configure the C++ plugin for JNI development, and resolve JDK 8 dependencies by using the unpack200 tool to enable NetBeans 8.2 C++ support.

Explore a simple Java/C++ JNI project in NetBeans, create native methods, generate headers, build a shared library, and load it to run fast computations from Java.

Explore how JNI header files bridge Java and C++ to fast-track numeric computations. Learn header naming, environment pointers, and loading one dynamic library for multiple native methods.

Explore setting up the Eclipse IDE for JNI development, generate native headers with javah or javac -h, and load the correct platform-specific dynamic library at runtime.

Learn to configure eclipse with a C++ development tool, generate JNI header files, build a dynamic library, and load it in Java using an external tool and static initialization.

Configures the external tool to generate JNI headers with Java c-edge for JDK 9 and later, builds a dynamic library, and loads it in Java using a system property path.

Demonstrates exporting a JNI-enabled Java project as a runnable jar and loading dynamic libraries by extracting them to a temp folder at runtime to resolve unsatisfied link errors.

Explore how the JNI overloads native methods by using unique parameter signatures and the Java naming convention with underscores. Overloading relies on differing parameter signatures, not on return types.

Explore how JNI handles overloaded native methods, including header generation, unique C++ signatures, and underscores encoding parameter types such as double, double array, and objects.

Learn how the Java Native Interface encodes overloaded native methods in C++ with underscores and signatures, and how headers are generated or written, including static versus instance methods.

Load the native library in the superclass static initializer to ensure it's loaded once during class loading. Static initializers run before constructors, and superclass loading happens before subclass execution.

Understand how JNI maps Java primitive types to native types and how signatures and arrays are encoded, using JNI defined types for portability.

Explore how JNI maps Java primitive arrays to C++ and back, using JNIEnv to create, copy, and transfer double arrays between Java and native code.

Explore working with object arrays in JNI, including two dimensional arrays and primitive arrays, and learn memory management across heap and stack with region copy and get/set operations.

Explore strings in the Java native interface. Convert between Java and C++ strings using env methods like new string UTF, get string UTF, and release string UTF, with memory management.

Learn to access static fields from C/C++ using JNI. The lecture covers locating the class, getting static field IDs, and using GetStatic... for string and int fields name and age.

Learn how JNI accesses and sets Java object fields from C++, including instance and static fields. Handle primitives and objects, use field IDs and signatures, and manage memory for strings.

Learn to speed up JNI by caching class and field IDs in C++ using method caching (local static) or global caching, reducing repeated JVM lookups.

Cache field IDs globally in JNI to avoid repeated lookups, initialize them once via a static initialization method, and boost performance when processing many objects.

Learn how to call instance and static Java methods from C++ using JNI, via method IDs, signatures, and parameter passing.

Discover how to call static and instance Java methods from C++ with JNI by obtaining class and method IDs, handling primitive and object returns, and using correct signatures.

Learn how to call methods of a Java interface from C++ using JNI, including static, default, and abstract methods, and leverage lambda expressions for functional interfaces.

Learn how to instantiate Java objects from C++ with JNI by locating the class, obtaining the constructor named init, and creating a new object with the correct signature.

Learn how to download, build, and install the GNU scientific library (GSL) from source, locate header files and dynamic libraries, and prepare for linking with Java via JNI.

Use the Java native interface (JNI) to call a C++ library from Java by writing native functions and linking to the GSL library.

Demonstrate JNI integration between Java and C++, focusing on boxed primitives and List<E> handling, including boxing, unboxing, and extracting primitive doubles, with tips to avoid boxing and prefer primitive arrays.

Explore nonvirtual calls in JNI to invoke a Java method from C++, bypassing virtual dispatch with a class and method ID, illustrated by animal, dog, and cat.

Learn to link against static C++ libraries in a multi-project eclipse workflow, manage headers, and prepare binaries for dependent projects. Explore how JNI relies on dynamic libraries loaded at runtime.

Explain how generics and parameterized methods interact with JNI, covering primitive boxing, type erasure to object, bounds and wildcards, and native method handling with C++ templates.

Explore the Java native interface (JNI) and generic (template) classes, focusing on type erasure, bounds, and runtime typing in JNI with C++ templates.

Learn to use jni with the Java reflection api to pass method and field objects to C++, retrieve their IDs, and reflect methods and fields for dynamic access.

Explore how Java static final primitive constants become C++ preprocessor defines in JNI headers, enabling compile-time value replacement in native code and clarifying which types translate.

Discover how to call Fortran libraries from Java via JNI, prototype external functions, handle pass by reference or pointer, and respect underscore naming conventions when linking.

Learn how the JNI header generator creates separate header files for each inner class, including nested and static inner classes, with mangled function names replacing dollar signs.

Explore how to instantiate static and non-static nested inner classes in JNI, including outer-class references, constructor signatures, class metadata, and creating and returning Java objects from C++.

Explore implementing native methods for Java inner and static nested classes in JNI, handling outer class references, class naming in C++, and method signature mappings.

Learn how JNI handles method-local inner classes, including header generation and underscore zero zero zero twenty four signatures, and contrasts static versus instance inner classes in native methods.

Explore implementing native methods in anonymous classes with JNI, including header file generation, anonymous class naming, unique C++ function names per anonymous class, and resolving native calls from Java.

Manage native resources with JNI by preventing memory leaks, using closable and automatic resource management, and implementing private native open and close methods instead of finalize.

Assign unique native file streams to each Java native file reader instance, mapping instance IDs to streams to prevent cross-instance conflicts, and manage open and close safely.

Explore implementing standard input and output in JNI by building a console in a class, loading a native library, and reading string, int, float, and double from the console.

Explore JNI by implementing a ConsoleOut class for standard output with native print methods and print line, wired to a C++ std::cout backend and a singleton console across the JVM.

Learn how to detect and handle Java exceptions from native C++ using JNI, including exception checks, clearing exceptions, and throwing new Java exceptions from C++.