In Java 8 and above you can create a List of Functional Interfaces to store the methods, as the following example shows:

// Create a list of Consumer
List<Consumer<String>> methodList= new ArrayList<>();

// Store the methods in the list
methodList.add(p -> method1(p));
methodList.add(p -> method2(p));
methodList.add(p -> method3(p));
methodList.forEach(f -> f.accept("Hello"));

Functions with no arguments you can use Runnable:

List<Runnable> methods = new ArrayList<>();
methods.add(() -> method1());
methods.add(() -> method2());
methods.add(() -> method3());
methods.forEach(f -> f.run());

First, create a functional interface that represents the common signature of all the functions. Note: there may be an interface from the java.util.function package that can be used to represent the signature, so it may not be necessary to create a new interface.

// for example
@FunctionalInterface
interface MyFunction {
    int f(int a, int b); // this must match the signature of each function
}

Then, create a List of that type.

List<MyFunction> functions = List.of(this::myFunction, MyClass::someOtherFunction);

Product::getInfo can be assigned to a Function<Product,Info> (since it's a non-static method, so it can be seen as a function that takes a Product instance and returns an Info instance). Change the declaration of functions from

List<Function> functions = new ArrayList<>();

to

List<Function<Product,Info>> functions = new ArrayList<>();

EDIT: I tested your code, and I get a different compilation error:

The type Product does not define getInfo(Object) that is applicable here.

The compilation error you got is misleading. Once I make the suggested change, the error goes away.

In Java, this is the best you can hope for. For each new function, you must make an additional change to ensure that it gets called. While you could pass an array of Functions to prevent setting up each individual call, you still need to alter the array with each successive function created, so it is ultimately no better.

Though if you're like me, you may want to categorize these functions so that you can have a single comprehensive list. While it doesn't reduce the amount of changes you'll need to make to the code, this way I find is more organized.

public enum TestFunctions {
    BUBBLE_SORT(SortingAlgorithms::bubbleSort),
    QUICK_SORT(SortingAlgorithms::quickSort),
    MERGE_SORT(SortingAlgorithms::mergeSort),
    INSERTION_SORT(SortingAlgorithms::insertionSort);

    UnaryOperator<Integer[]> function;

    private TestFunctions(UnaryOperator<Integer[]> function) {
        this.function = function;
    }

    public Integer[] call(Integer[] input) {
        return this.function.apply(input);
    }
}

Like this, your code can separate the function from where it's implemented. You'd still need to add the new function here, but there's no getting around this unless you used reflection. Though you could use reflection, I would strongly discourage you from doing so. My experience is that it tends to create more problems than it solves in the long run.

Good luck!