Customization

Basic Customization

basic and advanced... wouldn't it be great?

Advanced or Not-So-Basic Customization

There are two ways to further customize the behavior of |j2py|.

Advanced Advanced but It's-Still-Not-Hard Customization

Truly?

The java2python package can translate any syntactically valid Java source

code file. The generated Python code is not guaranteed to run, nor is

guaranteed to be syntactically valid Python. However, java2python works

well many cases, and in some of those, it creates perfectly usable and

workable Python code.

java2python copies identifiers from source to target, modifying the value only when:

Ternary expressions are translated to their Python form (`val if condition else other`)

In the case of `++` and `--`, java2python translates to `+= 1` and `-= 1`. If necessary, those expressions are moved outside of statements.

All of the following assignment operators are translated into their Python equivalents:

The bit shift right (`>>>`)and bit shift assign right (`>>>=`) operators are mapped to a function; if java2python detects code that uses either of these, it replaces the operator with that function and includes the function within the output. This behavior is controlled by the `modulePrologueHandlers` config handler.

Java arrays and array access expressions are translated to their Python equivalents.

interfaces are translated to classes utilizing the `ABCMeta` class. The package

includes config handlers that can translate to simple classes (inheriting from

`object`), or from Zope Interfaces. Interface base types are controlled via the `interfaceBaseHandlers` config item. The `interfaceHeadHandlers` config item controls the

metaclass.

includes a config handler to create class attributes with integer values. The config handler

that controls enumeration value construction is `enumValueHandler`.

Java `assert` statements are translated to equivalent Python `assert` statements.

Java `while` and `do` statements are translated to equivalent Python `while` statements.

Java `try` and `catch` statements are translated to equivalent Python `try` and `except` statements.

Java `switch` and `case` statements are translated to equivalent Python `if` statements.

In the case of a `synchronized` method or static method, the compiler will include a decorator, `@synchronized` in

the method or static method preamble. In the case of a `synchronized` block, the compiler will translate to this form:

The `lock_for_object` callable is the default and can be controlled via the `methodLockFunctionName` config item.

Also of note, the default `modulePrologueHandlers` uses a generator named `maybeSyncHelpers` to include

Java `return` statements are translated to equivalent Python `return` statements.

Java `break` statements are translated to equivalent Python `break` statements. However, a Java `break` statement with an identifier (e.g., `break FOO`) is not supported. If the compiler detects such a statement, a warning will be printed and the translated source will not

contain the original label.

Java `continue` statements are translated to equivalent Python `continue` statements. However, a Java `continue` statement with an identifier (e.g., `continue FOO`) is not supported. If the compiler detects such a statement, a warning will be printed and the translated source will not

contain the original label.

The `instance of` Java keyword is translated to the `isinstance(…)` Python function call.

The compiler translates Java `.class` expressions to `.__class__` attribute references.

The Java keyword `void` is typically discarded by the compiler. In the case of the `void.class` form, the compiler translates the expression to `None.__class__`.

Annotations are typically dropped by the compiler. The following Java annotations have little or no meaning in Python, and are discarded:

The `static` method keyword is translated to a `@classmethod` decorator for the corresponding method.

When used as a method or static method annotation, the `synchronized` keyword is translated to a `@synchronized` method decorator. This behavior is controllable via the `methodPrologueHandlers` config item.

Both Java end-of-line comments and multi-line comments are translated to Python comments. The comment prefix is `# ` by default, and is controllable via the `commentPrefix` config item.