Java Keywords (Part XXIV): native

Java keyword list

abstract continue for new switch
assert default goto* package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const* float native super while
Keyword marked with an asterisk (*) are keywords that, although valid, are not used by programmers.

This is the last chapter of the Java Keyword series. This is probably the keyword I have used the least. In my 20 year career as a software developer, I have used this keyword once, and that was to make some addition to legacy code.

The keyword native is a method modifier. Basically, it is a keyword that can only be applied to methods. According to the Java Language Specification (JLS),

A method that is native is implemented in platform-dependent code, typically written in another programming language such as C.
When I mentioned earlier that I used this keyword once to make some addition to legacy code, I had to call out some DLL's from our Java application. The legacy code were actually the DLL's. We wanted to incorporate these libraries that were coded in C++ in our new Java application, instead of coding all these features from scratch.

How to use the keyword

All you need to do is include the keyword native after the method's access modifier. It is as simple as that. Most of the time, you will simply create a method without body like the one shown below. 

public class MyClass {

    static {
        System.loadLibrary("Calculator");
    }
    
    public native double add(double x, double y); // This method has no body because the Calculator code does the work.
    
    public static void main(String[] args) {
        System.out.println(new MyClass().add(3.2, 5.4));
    }
}
If you had this Calculator program, running this code example would have displayed 

8.6
You could also have native methods with method body. 

public class MyClass {

    public native void initializeLibraries() {
        // Call some program here and do something else
    }
}
But I believe this is a bit unusual.The first usage is by far the most common. And that's it. I hope you found it useful. See you next time.

Although this is the "last" keyword, you should learn about a new keyword in the Java Language, the Java Record.

Comments

Post a Comment

Popular posts from this blog

Combining State and Singleton Patterns to Create a State-Machine

Image
In my previous two posts, I discussed real-world applications for the Singleton and State design patterns. In this article, I am going to illustrate how to combine both of these patterns to create a simple wizard. Simple State Design Pattern Implementation In a typical implementation of the design pattern, State is either an interface or abstract class, with each state of the state machine being Singleton classes. My example is going to be slightly different. I will implement the state machine using a state interface and Java enums to implement the Singleton. Using an enum is the recommended way to implement a Singleton in Java. First, let's come up with a simple state interface State.java public interface State { void goNext(Context input); void goPrevious(Context input); } Now that we have an interface defined, we can derive as many states as we need. For this example, three states should be sufficient to demonstrate the wizard's functionality. Jav
Read more

Exception Handling: File CRUD Operations Example

Image
Introduction to Exception Handling This is a supplement to my previous blog Creating Custom Exception Classes in Java . I recommend you read that one first and then read this one. Java provides many Exception (and Error) Handling classes. Both of these categories implement the Throwable interface. Although it is not imperative that you develop your own custom exception classes, it is often a good idea to do so; particularly when dealing with large systems. The main reason to create custom exception classes is to quickly identify which custom class is being affected or causing these custom exceptions. For example, referencing a null object and trying to use it will result in a NullPointerException . However, in your code, there could be literally hundreds or even thousands of statements which could result in such exception. Designing your Custom Exception Class Suppose that you are designing a class that will serve as a message receiver. For simplicity,
Read more

The Beauty of the Null Object Pattern

Image
Before we start... Let me start by saying this: NEVER dismiss an idea without giving it any consideration. That was the mistake I made when I first encountered an article about this design pattern many years ago. I was thrown off by the name and without even attempting to find out what this design pattern was all about, I moved on to other things. That was a huge mistake and I am not afraid to admit it. I urge you not to make that mistake. And if you have already, never make that mistake again. Trust me, you will thank me later. For now, let me tell you my story and attempt to explain when to use it along with a simple example on how to implement this pattern. The Null Object Pattern By definition, the main purpose of this pattern is to have an Object-Oriented alternative to the absence of objects by creating objects that display "do nothing" behavior. That sounds like a mouthful. In simplest terms, it is meant to provide a mechanism to replace null references w
Read more