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.

The method of a java.util.function.Function object is apply. You need to call it like this:

operations.get(i).apply(initialValue)

However you use raw Function and therefore the result could be Object and you'd need to convert it to the appropriate type. Also you can't use the + (or the +=) operator with it. I'd suggest restricting the parameter types with Number:

List<Function<Number, ? extends Number>> operations = Arrays.asList(
        num ->  num.intValue() + 1,
        num -> num.intValue() - 1,
        num -> num.doubleValue() * 3.14
        ); // just an example list here 

public double getResult() {
    double result = 0.0;

    for (int i = 0; i < operations.size(); i++) {
        if (i == 0) {
            result = operations.get(i).apply(initialValue).doubleValue();
        } else {
            result += operations.get(i).apply(result).doubleValue();
        }
    }
    return result;
}

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!

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

This has just been asked a few hours ago for a Consumer... You could reduce them to a single function and apply that:

@SafeVarargs
private static <T> Function<T, T> combineF(Function<T, T>... funcs) {
    return Arrays.stream(funcs).reduce(Function.identity(), Function::andThen);
}