JODE is a java package containing a decompiler and an
optimizer for java. This package is freely available under the GNU GPL.
New: The bytecode package and the core decompiler is now under
GNU Lesser General Public License, so you can integrate it in your
project.

The decompiler reads in class files and produces something
similar to the original java file. Of course this can't be
perfect: There is no way to produce the comments or the names of local
variables (except when compiled with debuging) and there are often
more ways to write the same thing. However, JODE does its job quite
well, so you should give it a try and start the
applet. Jode has support for all constructs of JDK-1.3 including
inner and anonymous classes.

The optimizer transforms class files in various ways with
can be controlled by a script file. It supports the following
operations:

Renaming class, method, field and local names to shorter,
obfuscated, or unique names or according to a given translation
table

Removing debugging information

Removing dead code (classes, fields, methods) and constant
fields

Optimizing local variable allocation

News

JODE 1.1.1 is out. With support for javac v8 (jdk 1.3).

The license changed to LGPL for the bytecode interface and decompiler.

Known bugs of the decompiler

Some jdk1.3 synthetic access functions aren't understood. The
produced source contains access$xxx functions, but it still compiles.

There may be other bugs, that cause Exceptions or invalid code.
If you have such a problems don't hesitate to issue a bug report.
Please include the class file if possible.

Limitations

If not all dependent classes can be found, the verifier (which is
run before decompilation starts) may exit with a type error. You
can decompile it with --verify=off, but take the warning
serious, that types may be incorrect. There's sometimes no way to
guess the right type, if you don't have access the full class
hierarchie.
This is not a bug in the verifier: java will complain the same way,
if it is run with bytecode verification turned on. And if you don't
have the dependent classes, you can't compile the code again.

There may be situations, where the code doesn't understand complex
expressions. In this case many ugly temporary variables are used, but
the code should still be compileable. This does especially happen
when you compile with `-O' flag and javac has inlined some
methods.