Java Methods - Taking a method AS AN ARGUMENT

Question

I've come across some code that I can't share here but it declares a method WITHIN the paramter list of another method. I didnt even know that was possible. I dont really understand why its doing that. Can someone please explain to me some possible uses that you as a programmer would have for doing that? (Note: Since I can't show the code I dont expect an in-context explanation just generally)

Related:

What's the nearest substitute for a function pointer in Java?

Solution 1

Did the code look something like this?

obj.someMethod(myVar,3,new FooObject() {
  public void bar() {
    return "baz";
  }
});

If so, then the method is not being passed to the other method as an argument, but rather an anonymous inner class is being created, and an instance of that class is being passed as the argument.

In the example above FooObject is an abstract class which doesn't implement the bar() method. Instead of creating a private class that extends FooObject we create an instance of the abstract class and provide the implementation of the abstract method in line with the rest of the code.

You can't create an instance of an abstract class so we have to provide the missing method to create a complete class defintion. As this new class is created on the fly it has no name, hence anonymous. As it's defined inside another class it's an anonymous inner class.

It can be a very handy shortcut, especially for Listener classes, but it can make your code hard to follow if you get carried away and the in line method definitions get too long.

Solution 2

In Java you can't pass methods as parameters. Could it have been passing not a method, but an anonymnous inner class?

This can be useful for passing behaviours between classes. Google "dependency injection" or "Inversion of control" for more information.

Solution 3

Have you ever seen the Functional Java? It's a very interesting library that allows you programing like you would do in Scala. I Wrote about this libs. I confess it is better to use in a more flexible syntax (BGGA closures) like Scala.

Using Functional Java with a high-order function like map on a list we have:

final List<Integer> numbers = list(1, 2, 3, 4, 5);  

List<Integer> c = numbers.map(new F<Integer, Integer>() {  
                 public Integer f(Integer arg) {  
                   return arg * arg;  
                  }  
              });  

Another useful lib is lambdaj that offers nice ways to play like in Functional (FP) Programming. Java has a limited syntax compared to FP languages. But you can still take some advantages of FP style, but you must be creative!

Solution 4

using java.lang.reflect.Method

example

public void callMethod(Method aMethod, int value) throws Exception {
    aMethod.invoke(this, value);
}

public void print(Integer value) {
    System.out.print(value);
}

public void println(Integer value) {
    System.out.println(value);
}

public void demo() throws Exception {
    Method println = this.getClass().getMethod("println", Integer.class);
    Method print = this.getClass().getMethod("print", Integer.class);
    callMethod(println, 10);
    callMethod(print, 10);
}

Solution 5

The nearest thing to passing a function pointer in Java is passing an anonymous instance of an abstract class or interface. For example, a generic function type can be encoded in an interface like this:

public interface F<A, B> {
  public B f(final A a);
}

You can then expect a method in another method's argument list:

public List<B> map(List<A> as, F<A, B> f) {
  ...
}

And you can call it with an anonymous instance of that interface:

map(myList, new F<Integer, String>() {
  public String f(Integer i) {
    return String.valueOf(i);
  }
});

There's a library called Functional Java that exploits exactly this idea for great benefit glorious language Java.

View more solutions