Lambdas are purely a call-site construct: the recipient of the lambda does not need to know that a Lambda is involved, instead it accepts an Interface with the appropriate method.

In other words, you define or use a functional interface (i.e. an interface with a single method) that accepts and returns exactly what you want.

Since Java 8 there is a set of commonly-used interface types in java.util.function.

For this specific use case there's java.util.function.IntBinaryOperator with a single int applyAsInt(int left, int right) method, so you could write your method like this:

static int method(IntBinaryOperator op){
    return op.applyAsInt(5, 10);
}

But you can just as well define your own interface and use it like this:

public interface TwoArgIntOperator {
    public int op(int a, int b);
}

//elsewhere:
static int method(TwoArgIntOperator operator) {
    return operator.op(5, 10);
}

Then call the method with a lambda as parameter:

public static void main(String[] args) {
    TwoArgIntOperator addTwoInts = (a, b) -> a + b;
    int result = method(addTwoInts);
    System.out.println("Result: " + result);
}

Using your own interface has the advantage that you can have names that more clearly indicate the intent.

You can use a Supplier and constructor reference:

public static void main(String[] args) {
  new Parser(new File[]{}, Template1::new);
}

Parser(File[] files, Supplier<Template> templateFactory) {
  for (File f : files) {
    Template t = templateFactory.get();
  }
}

The Function type could be used for a one-argument constructor like Template1(File):

public static void main(String[] args) {
  new Parser(new File[]{}, Template1::new);
}

Parser(File[] files, Function<File, Template> templateFactory) {
  for (File f : files) {
    Template t = templateFactory.apply(f);
  }
}

The Java 8 API provides a number of standard functional interfaces in the java.util.function package though these typically don't extend beyond two arguments. You can either use 3rd party nary functional interfaces (I made some for KludJe) or write your own.

A custom implementation might look like this:

public static void main(String[] args) {
  new Parser(new File[]{}, Template1::new);
}

Parser(File[] files, TemplateFactory templateFactory) {
  for (File f : files) {
    Template t = templateFactory.createFrom(f);
  }
}

public static interface TemplateFactory {
  Template createFrom(File file);
}

Interestingly enough, your current lambda expression will work for this (barring the fix to the typo of system.out.println). The below is merely a more concise way to express it.

Effectively, you're writing out a method that takes in two values, produces one, and places it in some sort of consumer. That consumer could be a collection, some function that can handle the result, or another object.

Let's take lambdas out of the equation for a moment and write this out with an anonymous class.

x.sum(1, 2, new Consumer<Integer>() {
    @Override
    public void accept(final Integer value) {
        // what should go here?
    }
});

We need to tell this result where to go. We've got a few options:

• A Collection (List, Set, etc)
• A new reference object
• A method reference that accepts the parameter

Let's take the simplest approach and simply print it out.

x.sum(1, 2, new Consumer<Integer>() {
    @Override
    public void accept(final Integer value) {
        System.out.println(value);
    }
});

Now, this makes some sense - we're taking the result of two numbers, adding them together, and then printing the result to the screen.

Let's put lambdas back into the mix. This can be expressed in terms of a lambda in this manner:

x.sum(1, 2, System.out::println);

Effectively, whatever resultant value we get back, we wish to then allow the println method to consume it.