How do I pass method as a parameter in Java? [duplicate]

Question

Possible Duplicate:
Java Pass Method as Parameter

Is it possible to pass a method as a parameter in Java? If I can't what would be the best course of action for the method below without having to repeat code.

public void enterUserInput(javax.swing.JTextField inputField, javax.swing.JTextField   outputField, method rangeChecking){

    String input;
    double output;
    input = inputField.getText();
    output = Double.parseDouble(input);
    if(rangeChecking(output)){
        outputField.setText(input);
        inputField.setText(null);
    }

I will be calling a rangeChecking method from a different class and each time I call the enterUserInput the rangeChecking method will be different

Answer 1

You should use an interface to do it.

You pass the interface that declares the desired function to the method, and invoke the desired method. The specific method that will be invoked is the one implemented by the implementing class.

It is called the strategy design pattern.

code sample:

public static interface Foo { //this is the interface declaration
    public void print();
}
public static class Bar implements Foo { //Bar is an implementing class
    public void print() {
        System.out.println("Bar");
    } 

}
public static void test(Foo foo) { //the method accepts an interface
    foo.print(); //and invokes it, the implementing class' print() will be invoked.
}
public static void main(String... args) throws Exception {
    test(new Bar()); //invoke test() with the class implementing the interface
}

Answer 2

Create an interface with that method signature, and pass an anonymous subclass of it with your method implementation.

// the interface that contains the method/methods you want to pass
interface MethodWrapper {
    public void method(String s); }

// ...
// in your code
// assuming that "observable" is an object with a method "setCallback" that 
// accepts the callback
// note that your method implementation will have access to your local variables

public void someMethodOfYours() {
    observable.setCallback(new MethodWrapper() {
        public void method(String s) {
            System.out.println(s);
        } }
    );
    // note that your anon subclass will have access to all your contain method 
    // locals and your containing class members, with [some restrictions][1]
}

// in the "observable" class - the class that receives the "callback method"
// ...

if( updated() ) {
    callback.method("updated!"); }

In future versions of java (with the advent of lambdas) you won't have to define the interface and the anonymous inner class - there will be specific lambda syntax which will compile to the equivalent bytecode.

[1] Cannot refer to a non-final variable inside an inner class defined in a different method

Answer 3

Not as far as I know. This is generally done by making an interface that has the method you want and passing a class that implements that interface in.

public interface IRangeCheck
{
    boolean check(double val);
}

public class RangeChecker implements IRangeCheck
{
    public boolean check(double val)
    {
        return val > 0.0;
    }
}

...
    public void blabla(..., IRangeCheck irc)
    {
        ...
        if(irc.check(output))
           ...
    }