Reputation: 17140

Java Methods - Taking a method AS AN ARGUMENT

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)

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

Upvotes: 5

Answers (12)

Soyoes

Reputation: 940

not pointer, but still you can write functions inline with some trick.

check my answer on another thread

Upvotes: 0

paulosuzart

Reputation: 1092

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!

Upvotes: 4

Andreas Petersson

Reputation: 16518

the closest to a function argument is

an instance of a anonymous class with exactly one method.

    Runnable a = new Runnable(){

   run(){
    System.out.println("hello");
        }
    }

  myMethod(a);

Upvotes: 0

Apocalisp

Reputation: 35054

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.

Upvotes: 3

Adam Jaskiewicz

Reputation: 10986

You can also do something like this:

final Predicate somePredicate = new Predicate<Item>() 
  {
  @Override
  public boolean apply(Item item)
    {
    return item.someProperty().equals(something);
    }
  }

And use it like this:

List<Item> filteredList = filter(list, somePredicate);

I've done stuff like that before. I've also written methods that use a closure to build and return an anonymous implementation of an interface in a similar way:

Predicate isSomeColor(final Color color)
  {
  return new Predicate<Shape>() 
    {
    @Override
    public boolean apply(Shape shape)
      {
      return shape.getColor().equals(color);
      }
    }
  }

List<Shape> redShapes = filter(shapes, isSomeColor(Color.RED);

All of this is still anonymous inner classes. Nowhere am I actually naming the class itself, I just have a reference to an instance of the class.

Upvotes: 1

Diego

Reputation: 17140

The answers above are varying as to whether or not it is even possible. Is it possible through reflection? Is possible through the use of an anonymous inner class? We need to clarify this.

Upvotes: 0

Sourabh

Reputation: 1615

Yes, declaration of a method within the parameter list of another method can be done. You can check out java.lang.reflect.Method

Using reflection, you retrieve a Method object representing the method you wish to pass as a parameter. Then you can call Method to invoke to make a call to that method.

Moreover, you can refer "Functional programming in the Java language" (http ://www.ibm.com/developerworks/java/library/j-fp.html) which can give you inside-out with examples.

Upvotes: 0

David Webb

Reputation: 193696

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.

Upvotes: 24

dfa

Reputation: 116304

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);
}

Upvotes: 3

Amir Arad

Reputation: 6754

this is called reflection. there is a whole library of objects representing stuff like constructors, methods and such.
you can use it, for instance, in order to call a dynamic method that is determined on runtime.

Upvotes: 0