| Step By Step

## Step 3: Create the .h File

> In this step, you use the `javah` utility program to generate a header file (a `.h` file) from the `HelloWorld` Java class. The header file defines a structure that represents the `HelloWorld` class on the native language side, and provides a function definition for the implementation of the native method `displayHelloWorld()` defined in that class.

> Run `javah` now on the `HelloWorld` class that you created in the previous steps.

> By default, `javah` places the new `.h` file in the same directory as the `.class` file. You can tell `javah` to place the header files in a different directory with the `-d` option.

> The name of the header file is the Java class name with a `.h` appended to the end of it. For example, the command shown above will generate a file named `HelloWorld.h`.

> #### The Class Structure

> > Look at the header file `HelloWorld.h`.

> > >     #includejava example/HelloWorld.h

> > Notice that it contains a `struct` definition for a structure named `ClassHelloWorld`. The members of this structure parallel the members of the corresponding Java class; that is to say, the fields in the `struct` correspond to instance variables in the class. But since `HelloWorld` doesn't have any instance variables, there is just a place holder in the structure. You can use the members of the `struct` to reference class instance variables from your native language functions.

> > Also, notice that the header file contains this line:

> > >     HandleTo(HelloWorld);

> > This creates a `typedef struct` named `HHelloWorld`, which you use to pass objects between Java and another language.

> #### The Function Definition

> > In addition to the structure that mimics the Java class, you will also notice a function signature that looks like this:

> > >     extern void HelloWorld_displayHelloWorld(struct HHelloWorld *);

> > This is the definition for the function that you will write in Step 5: Write the Native Method Implementation that provides the implementation for the `HelloWorld` class's native method `displayHelloWorld()`. You must use this function signature when you write the implementation for the native method. If `HelloWorld` contained any other native methods, their function signatures would appear here as well.

> > The name of the native language function that implements the native method is derived from the package name, the class name, and the name of the Java native method. Thus, the native method `displayHelloWorld()` within the `HelloWorld` class becomes `HelloWorld_displayHelloWorld()`. In our example, there is no package name because `HelloWorld` is in the default package.

> > You will notice that the native language function accepts a single parameter even though the native method defined in the Java class accepts none. You can think of the parameter as the "this" variable in C++. Our example ignores the "this" parameter. The next lesson, Implementing Native Methods, describes how to access the data in the "this" parameter.

| Step By Step