javaclass

The javaclass collection of packages and utilities (also known as ClassFile) provides a means of importing Java classes and packages directly into Python, without the need for a Java virtual machine, so that the classes may be instantiated, accessed, run and manipulated just like Python classes, and that the resulting objects and methods can be accessed and manipulated just like Python objects and methods.

Quick Examples

It can be quicker to see what this is about by seeing some examples.

The Not Very Convincing Example

You can run Java classes by finding one with a main method and executing it. Here's a comparison of a freshly prepared Java class being run in Python and in a Java virtual machine:

cd tests/

javac Value.java

runclass.py Value

v.getValue() correct: 123
v.getValue() correct: 456
v.isPositive() correct: 1
v.isPositive() correct: 0
v.compare(-790) correct: -1
v.compare(-788) correct: 1
v.compare(-789) correct: 0
v.getValue() == v2.getValue() correct: 0
v2.add(-123) correct: 0
v2.getValue() correct: 255

java Value

v.getValue() correct: 123
v.getValue() correct: 456
v.isPositive() correct: true
v.isPositive() correct: false
v.compare(-790) correct: -1
v.compare(-788) correct: 1
v.compare(-789) correct: 0
v.getValue() == v2.getValue() correct: false
v2.add(-123) correct: 0
v2.getValue() correct: 255

The Slightly More Credible Example

It can be more interesting to get into Python's interactive mode and then start playing around with Java classes:

Python 2.2.2 (#2, Jan 21 2005, 16:16:57)
[GCC 2.96 20000731 (Red Hat Linux 7.3 2.96-112)] on linux2
Type "help", "copyright", "credits" or "license" for more information.

import javaclass.classhook

from __this__ import Value

dir()

['Value', '__builtins__', '__doc__', '__name__', 'javaclass']

dir(Value)

['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__init______I_', '__module__', '__new__', '__reduce__', '__repr__', '__setattr__', '__str__', '__weakref__', 'add', 'add____I_', 'compare', 'compare____I_', 'getClass', 'getClass___', 'getValue', 'getValue___', 'isPositive', 'isPositive___', 'main', 'main___java__lang__String_array_', 'newValue', 'newValue___', 'setValue', 'setValue____I_']

v = Value(20050121)

v.getValue()

20050121

v.setValue(20050401)

v.getValue()

20050401

Motivation

Pick one of the following:

• The need/desire to access Java libraries from Python without firing up Java virtual machines or switching to Jython (and thereby losing access to various CPython libraries).
• Static typing for the Python environment, albeit achieved by writing Java or other appropriate languages.
• Having an open source environment from top to bottom to run Java bytecode on.
• Experimentation around import hooks, bytecode generation; observation of different runtime and type systems interacting.
• Using Python libraries from Java.

Limitations

It isn't all great, however. Here are some reasons why this might not do what you want it to:

• It runs on the Python runtime which does not have the security, threading and just-in-time compiler features that people enjoy about Java runtimes, so if what you like to do is to run one big servlet container with lots of classes and threads from different people floating around, this isn't going to protect them from doing all sorts of things to each other and to your system. However, you may take the unfashionable view that the operating system is supposed to do that kind of thing.
• It works by generating Python bytecode from the Java bytecode in class files (and .jar archives). Generally, anyone who is anyone in the Python pantheon has largely recommended against doing anything with the bytecode, despite noble efforts to make exciting things happen by transforming it, optimising it, and so on -