Given a java file, I will parse it and find all the classes/interfaces missing, and add the corresponding import statement at the start of the java source file.

1. The java.lang.* and classes under the current package are recognized so, and not bothered.
2. When the supporting script (described below) find more than one class in the whole project with the same name, the elisp command completing-read will be used to trivially prompt you to choose one, as you can see in the video or the screenshot below:

   

   Note that I am using anything.el (now renamed as helm) to make completing-read even more friendly.

I can use this command to draw the inheritance tree of a class I am interested in.

Compared to what was provided by Eclim, mine will provide these very useful pieces of information:

1. Where are all the classes/interfaces in the inheritance tree defined.

   This information is provided in a compilation-mode buffer, so that you can easily jump over.

2. Where is the current method defined in all the classes/interfaces of the inheritance tree.
3. The java.lang.Object will be shown for the class which as no extends clause in its declaration.
4. If required (with an option flag for the underlying perl script), list all the methods/fields of all the classes/interfaces in the tree (see usage below, see FIXMEs below).

You can see it in the video, or the below screenshot, note how the onCreate method has been show below each of the classes who defines it.

Here is another one showing a similar class and the onKeyUp method.

This method seem to be not very useful, but it is depended upon by the next very useful command.

To put it simply, put the point behind xx. below and invoke this command, and it will tell you its type is java.util.ArrayList or simply ArrayList, depending on whether you have imported ArrayList.

ArrayList<String> xx;
xx.  <= put point here and M-x ajoke-resolve

As said above, if you put point after xx. and invoke ajoke-complete-method, it will let you completing-read choose from all the methods of ArrayList (and its superclass and interfaces's).

It works by reusing ajoke-resolve on xx and find its type ArrayList, then ajoke-get-hierarchy on ArrayList to list all its methods.

See the video or the below screenshot:

You may need to redefine a method of a parent class/interface, this elisp command can come to help. You can completing-read choose which method to override. See the video or the screenshot:

cd ~/system-config/gcode/java-test
for-code-reading
ajoke-get-hierarchy.pl Child -m Child

You should see output like the following:

=> class com.human.Child at com/human/Child.java line 2.
   => interface com.human.Mother at com/human/Mother.java line 2.

• Not a separate project.

  This will give other people a very difficult choice to use my scripts.

• only works with android

  Because all the class/method/field information is extracted from the java source file using ctags-exuberant, and not from some .jar files in the CLASSPATH, the whole java system source code must be present for this system to work.

  Android is the only system I know that satisfies this high-demanding condition. Maybe I will work on this someday when I need write a non-Android project.

• Some commands are too slow (several seconds to complete a method)

  I think I should someday add additional caching for better performance.

• ajoke-get-import

  It should not offer to import the android resouce class android.R, because an APK project will generate its own R.java in the same package.

  And it does not handle generic types very well.

• ajoke-resolve

  It parse String[] strArr as java.lang.String, not as Array.

• ajoke-get-hierarchy

  When asked to list all methods/fields, it will literally list everything, even private ones.

• ajoke-get-override
  1. Should support batch overriding for e.g., all the methods of an interface.
  2. Methods already defined should be filtered out and not offer to be overridden again.

ctags-exuberant and global are heavily used.

In that video, you will see me type a skeleten and get it completed, this idea is very much like anything.el or (as I think) icicle, ido, etc. You may also find the Firefox browser's URL completion similar to this idea.

The usual Emacs completion require matching at the head, for e.g., if you want to complete this identifier, savedInstanceState, you must type in the beginning part of it sav, or saved, and press M-/ to hippie-expand it. This can be sometimes a bit inconvenient.

With my completion, I can start typing anything that is in the identifier, such as state or sainst, or vedstst, as long as the characters are in the same order as the original word. Here the skeleton vedstst will be rewritten as a regexp by using (mapconcat 'string "vedstst" ".*") as v.*e.*d.*s.*t.*s.*t, which matches and completes to the target savedInstanceState.

When there are multiple matches, hippie-expand (by default) will rotate the completions one-by-one, and I have never found out how to rotate backwards if I rotated one past the right choice. Undo?

With my completion, all the choices are listed in the rough order how far they are found from the point (I think hippie-expand will try all matches after the point, then all those before the point; mine will interleave them), and you can scroll up and down the list (just like anything.el's completing-read).

This tool is so convenient that I don't find some of my java-coding scrits's bugs so urgent to fix.

You can see in the video or the below screenshot:

You can find the elisp source in skeleton-complete.el.

I have not tried them. Not a big fan of ecb/cedet etc. because these tools are not friendly when using them with TRAMP.

I tried ANTLR, but found it too heavy and too slow.

But while trying ANTLR, I learned how Java is a very regular language compared to C and C++, since it has no preprocessor. So I devised a simple script to turn a Java source file into its truely most regular form (hopefully still a 95% valid java program):

1. Get rid of all comment, all whitespace that won't affect sematic when removed, and all string/character literals (replacing them all with empty string literal ("").

   An white space between 2 words such as public and int is non-removable, but a space character after the > in ArrayList<String> can be safely removed (I think).

2. Insert a newline after these 3 characters (;{}).
3. Indent it properly if you want it to be more beautiful to the eyes.

An example follows. Given this wildly irregular piece of Java code, notice how difficult it will be to figure out that the prototype of getWordIdx is @Override public int getWordIdx(String word){ (maybe without the @Override and the {), or even to tell that there is a method named getWordIdx:

class test 
implements
    stintf {

/*
watch how the following very irregular method will be formatted
beautifully

*/

    @Override
    public
        int
        getWordIdx(String
 word) 
    {
ArrayList<String> xx;
if (word == "hello world") {
        return
            0;
    }
    }
}

You can use flatten.pl to filter it into the following highly regexp matchable piece of Java, and you can easily extract the whole prototype of the getWordIdx method, or the class declaration line for test:

class test implements stintf{
    @Override public int getWordIdx(String word){
        ArrayList<String>xx;
        if(word==""){
            return 0;
        }
    }
}