Commit c5ed5b7

}

As of release 0.4.5 it became possible to create async methods that return promises by setting the `asyncOptions` property of the java object. With release 0.4.7 this feature is extended to allow changing the suffix assigned for sync and async method variants, and to further configure this module to optionally omit generation of any of these variants.

* NOTE: Due to specifics of initialization order, the methods `java.newInstancePromise`, `java.callMethodPromise`, and `java.callStaticMethodPromise` are not available until the JVM has been created. You may need to call some other java method such as `java.import()` to finalize java initialization, or even better, the function `java.ensureJvm()`.

Methods accepting varargs of a generic type are also problematic. You will need to fall back to using `java.newArray()`. See [Issue #285](https://github.com/joeferner/node-java/issues/285).

* [classpath](#javaClasspath)

* [options](#javaOptions)

* [import](#javaImport)

* [newInstance](#javaNewInstance)

* [instanceOf](#javaInstanceOf)

<a name="javaClasspath" >

*java.classpath**

Array of paths or jars to pass to the creation of the JVM.

java.classpath.push('commons.io.jar');

java.classpath.push('src');

<a name="javaOptions" >

*java.options**

java.options.push('-Djava.awt.headless=true');

java.options.push('-Xmx1024m');

<a name="javaImport" >

*java.import(className)**

__Arguments__

var test = new Test();

list.instanceMethodSync('item1');

<a name="javaNewInstance" >

*java.newInstance(className, [args...], callback)**

// new list

});

<a name="javaInstanceOf" >

*java.instanceOf(javaObject, className)**

console.log("obj is an instance of SuperClass");

}

<a name="javaCallStaticMethod" >

*java.callStaticMethod(className, methodName, [args...], callback)**

// results from doSomething

});

<a name="javaCallMethod" >

*java.callMethod(instance, methodName, [args...], callback)**

// results from doSomething

});

<a name="javaGetStaticFieldValue" >

*java.getStaticFieldValue(className, fieldName)**

var data = java.getStaticFieldValue("com.nearinfinty.MyClass", "data");

<a name="javaSetStaticFieldValue" >

*java.setStaticFieldValue(className, fieldName, newValue)**

java.setStaticFieldValue("com.nearinfinty.MyClass", "data", "Hello World");

<a name="javaNewArray" >

*java.newArray(className, values[])**

var newArray = java.newArray("java.lang.String", ["item1", "item2", "item3"]);

<a name="javaNewByte" >

*java.newByte(val)**

var b = java.newByte(12);

<a name="javaNewShort" >

*java.newShort(val)**

var s = java.newShort(12);

<a name="javaNewLong" >

*java.newLong(val)**

var s = java.newLong(12);

<a name="javaNewChar" >

*java.newChar(val)**

var ch = java.newChar('a');

<a name="javaNewDouble" >

*java.newDouble(val)**

var d = java.newDouble(3.14);

<a name="javaNewFloat" >

*java.newFloat(val)**

var f = java.newFloat(3.14);

<a name="javaNewProxy" >

*java.newProxy(interfaceName, functions)**

var thread = java.newInstanceSync("java.lang.Thread", myProxy);

thread.start();

<a name="javaisJvmCreated" >

*java.isJvmCreated()**

Returns true if the JVM has been created. The JVM can only be created once.

<a name="javaRegisterClient" >

*java.registerClient(before, after)**

Register that a client wants to be called back immediately before and/or immediately after the JVM is created. If used, this function must be called before the JVM has been created. The before function is typically used to add to the classpath. The function may execute asynchronous operations (such as a async glob function). The after function is sometimes useful for doing one-time initialization that requires the JVM to first be initialized. If either function is unnecessary, use `null` or `undefined`. See also `registerClientP` and `ensureJvm`. See the unit tests in `testAsyncOptions` for examples.

<a name="javaRegisterClientP" >

*java.registerClientP(before, after)**

Like java.registerClient, but before and after are assumed to be functions returning promises.

<a name="javaEnsureJvm" >

*java.ensureJvm(callback)**

<a name="javaObject">

<a name="javaObjectCallMethod" >

if(err) { console.error(err); return; }

});

<a name="javaObjectGetSetField" >

*obj._fieldName_ = val**

list.data = "test";

var data = list.data;

Run `javap -s -classpath <your-class-path> <your-class-name>`. Find the method name you are looking for. For example:

When you call a Java method through node-java, any arguments (V8/JavaScript objects) will be converted to Java objects on the v8 main thread via a call to v8ToJava (found in utils.cpp). The JavaScript object is not held on to and can be garbage collected by v8. If this is an async call, the reference count on the Java objects will be incremented. The Java method will be invoked in a node.js async thread (see uv_queue_work). When the method returns, the resulting object will be returned to the main v8 thread and converted to JavaScript objects via a call to javaToV8 and the Java object's reference count will then be decremented to allow for garbage collection. The resulting v8 object will then be returned to the callers callback function.

var Test = java.import('Test');

var value1 = Test.NestedEnum.Value1;

public class Test {

}

var Test = java.import('Test');