Java Pass Method as Parameter

Master the Art of Method References

Boost code readability using method references in Java 8. They are simplified versions of lambdas referring directly to methods:

import java.util.function.Consumer;

public class MethodReferenceExample {
    public static void main(String[] args) {
        Consumer<String> printer = System.out::println; // Because shouting at console never gets old
        useConsumer("Hello, World!", printer); // Console says "What? Again?"
    }

    public static void useConsumer(String str, Consumer<String> consumer) {
        consumer.accept(str);
    }
}


Here, System.out::println serves as a method reference fitting the Consumer<String> functional interface, much like a key fits into a lock.

Match the method to the job

Different use-cases require different functional interfaces. Choose the interface that fits snugly with your method's signature:

• Employ Function<T, R> when there's a return value.
• Use Consumer<T> for operations that return zilch.
• Slide in BiFunction<T, U, R> for methods with two parameters.
• Create custom interfaces if your method feels left out with more than two parameters.

import java.util.function.BiFunction;

public class BiFunctionExample {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b; // Adding integers because... why not?
        int sum = applyBiFunction(3, 4, adder); 
        System.out.println(sum); // Spoiler: It's 7
    }

    public static int applyBiFunction(int a, int b, BiFunction<Integer, Integer, Integer> func) {
        return func.apply(a, b);
    }
}


In the example above, adder is a lambda expression acting as a bridge between two integers, compatible with the BiFunction<Integer, Integer, Integer> interface.

Navigating with Design Patterns

Approach more structured scenarios using the Command pattern. Encapuslate and wrap calls within a class to pass as objects:

interface Command {
    void execute();
}

class PrintCommand implements Command {
    private final String message;

    public PrintCommand(String message) {
        this.message = message;
    }

    @Override
    public void execute() {
        System.out.println(message);  // Because wrapping a simple message like a ninja!
    }
}

// Use it in the excursion 
void callCommand(Command command) {
    command.execute(); // Command the command to execute!
}


This approach encapsulates actions, enabling you to handle, dispatch, and invoke them later.

Handling Complex Structures with Visitor

For intricate traversals allowing operations on varying object structures, the Visitor pattern kicks in:

interface NodeVisitor {
    void visit(Node node);  // Meet and greet with the Node
}

class Node {
    void acceptVisitor(NodeVisitor visitor) {
        visitor.visit(this);
        // Additional invitation logic for nested elements…
    }
}


Nodes have an acceptVisitor(NodeVisitor) method, where a visitor can carry out tasks specified in its visit method.

Reflection: Delve Deeper

Reflection in Java, particularly java.lang.reflect.Method and invoke(), provides versatility when method names are rather elusive at compile-time:

import java.lang.reflect.Method;

Method method = MyClass.class.getMethod("myMethod"); // Detected a method, detective mode on!
method.invoke(instanceOfMyClass);


Though flexible, reflection carries a performance cost and less type safety. Thus, use such powers prudently.