my_inst = MyClass.new(...)
init_method = my_inst.java_class.java_method :initialize
init_method.invoke(Java.java_to_ruby(my_instance))

I've been meaning for a while to implement a java_call method that works like this:

result = my_inst.java_call :my_method, 'an arg or', 2

Args and the result would be converted automatically.

Comments?

I think jruby should provide a standard mechanism that works in all cases (class and instance methods).

irb(main):046:0> pool.class
=> Java::ComDangaMemCached::SockIOPool

irb(main):047:0> init_method = pool.java_class.java_method :initialize
=> #<Java::JavaMethod/initialize()>

irb(main):048:0> init_method.invoke(Java.java_to_ruby(pool))
TypeError: invokee not a java object

class Java::JavaLang::Object
def java_call(method_name, *params)
jcls = self.java_class
m = jcls.declared_method(method_name, *params.map do |x|
x[0].to_s =~ /^[A-Z]/ ? eval("java.lang.#{x[0]}"): x[0]
end)
m.invoke self.java_object, *params.map{|x| Java.ruby_to_java(x[1])}
end
end

1. Examples of usage:

Tescior.new.java_call :initialize
Tescior.new.java_call :initialize, [:String, "World!"]
Tescior.new.java_call :initialize, [:int, 7], [:Integer, 8]
Tescior.new.java_call :initialize, [:Integer, 9], [:Integer,10]

It is necessary to pass parameter types because knowing method name is not enough to pick up the methods. Java uses method overloading. JRuby does not distinguish between int and Integer. Look at third and forth method below.

public class Tescior {
public void initialize() { System.out.println("initialize is reserved for constructor in JRuby"); }
public void initialize(String name) { System.out.println("Hello " + name); }
public void initialize(Integer x, Integer y) { System.out.printf("%s + %s = %s\n", x,y,(x+y)); }
public void initialize(int x, Integer y) { System.out.printf("%s + %s = %sn", x,y,(x+y)); } }
}

public class Foo {
  public String initialize() { return "foo"; }
}

In Ruby:

Foo.new.send("initialize$method") # returns "foo"

Future versions JRuby will allow targeting specific signature methods through similiar name-mangling (though not for 1.1.6).

New method is __method as suffix. This has an extremely slight possibility of name conflict (very extremely), but it is directly callable:

public class Foo {
  public String initialize() { return "foo"; }
}

In Ruby:

initialize__method # returns "foo"