functional-interface

I'm learning about Method References from Java 8 and I have difficulties understanding why does this work? class Holder { private String holded; public Holder(String holded) { this.holded = holded; } public String getHolded() { return holded; } } private void run() { Function<Holder, String> getHolded = Holder::getHolded; consume(Holder::getHolded); //This is correct... consume(getHolded); //...but this is not } private void consume(Consumer<Holder> consumer) { consumer.accept(null); } As you can see in run method - Holder::getHolded returns unbound method reference which you can invoke by

I'm just starting to learn Camel and the first thing I see is context.addRoutes(new RouteBuilder() { public void configure() { from("file:data/inbox?noop=true").to("file:data/outbox"); } }); which I (reasonably IMHO) try to replace with context.addRoutes(()->from("file:data/inbox?noop=true").to("file:data/outbox")); but that is not valid. As I dig, I discover that lambdas apply to functional interfaces (which is be implied, if the interface qualifies) but that the @FunctionalInterface annotation can only be applied to interfaces (fair enough) and there is, as far as I can tell, no equivalent

Why do suppliers only support no-arg constructors? If the default constructor is present, I can do this: create(Foo::new) But if the only constructor takes a String, I have to do this: create(() -> new Foo("hello")) That's just a limitation of the method reference syntax -- that you can't pass in any of the arguments. It's just how the syntax works. Brian Goetz But, a 1-arg constructor for T that takes a String is compatible with Function<String,T> : Function<String, Foo> fooSupplier = Foo::new; Which constructor is selected is treated as an overload selection problem, based on the shape of

This question already has an answer here: Explicitly calling a default method in Java 4 answers In java 8 I have something like this: package test; public class SimpleFuncInterfaceTest { public static void carryOutWork(AFunctionalInterface sfi){ sfi.doWork(); } public static void main(String[] args) { carryOutWork(() -> System.out.println("Do work in lambda exp impl...")); AImplementor implementsA = new AImplementor(); //carryOutWork(() -> implementsA.doWork()); BImplementor implementsB = new BImplementor(); carryOutWork(() -> implementsB.doWork()); } } @FunctionalInterface interface

The definition of a functional interface is "A functional interface is an interface that has just one abstract method (aside from the methods of Object ), and thus represents a single function contract." According to this definition, the Comparable<T> is definitely a functional interface. The definition of a lambda expression is "A lambda expression is like a method: it provides a list of formal parameters and a body - an expression or block - expressed in terms of those parameters." Evaluation of a lambda expression produces an instance of a functional interface. Thus, the purpose of the

Java 8 gave us many fun ways to use functional interfaces and with them a new annotation: @FunctionalInterface . Its job is to tell the compiler to yell at us if we fail to stick to the rules of a functional interface (only one abstract method that needs overriding please). There are 43 interfaces in the java.util.function package with this annotation. A search of jdk.1.8.0/src for @FunctionalInterface only turns up 57 hits. Why are the other interfaces (such as AutoCloseable) that could have added @FunctionalInterface still missing it? There is a bit of a vague hint in the annotations