A buddy of mine has been working on java for microcontrollers etc:
https://github.com/mikeakohn/java_grinder

For fun/learning I am doing the 6502 part. The idea is basically to compile the java byte code into assembly. There are limitations:

-integers are 16-bit, shorts are treated like integers
-stack is always aligned to 16-bit
-division/modulus is unsigned only
-you can have 8/16 bit arrays (byte/int)
-no floating point etc

He made it so you can extend a processor to a particular platform, and make corresponding java classes. Pretty cool. So I extended 6502 to the C64, and am working on an API for that. Not everything in java is supported, but basically you make one class file, and include static methods within that to do what you want.

There is a Mandelbrot demo for the C64. The latest naken_asm from github (see above) is required for this to work:
https://github.com/mikeakohn/naken_asm


That builds the API..


Then use naken_asm to compile:


Now test.prg will run in a c64 emulator such as VICE:


Mike's pages for java_grinder and naken_asm with more information:
http://www.mikekohn.net/micro/java_grinder.php
http://www.mikekohn.net/micro/naken_asm.php

You might also be interested in taking a look at VM02, a similar Java-for-the-6502 project David Schmenk put up a few years ago:

http://sourceforge.net/projects/vm02/

Sweet, I never would have imagined an actual interpreter.

Re-wrote some of this today, changed the game plan a bit. Now using the processor stack solely for jsr/rts etc, and made a parallel stack of 256 lo/256 hi bytes for variables. This frees up the 6502 stack and allows 256 16-bit variables to be on the java stack.

Also now either inlines code if there is a constant involved (shifts can be unrolled etc) or will only include a subroutine if it's actually needed. (The code inlining saves a few cycles but not too much, so I'm not sure it's really worth the bloat.)

Haven't updated the code yet but will after I debug a bit more.