functional-interface

When I'm shooting a glance at lambda expressions, the book touches on a functional interface that has only one abstract method. My issue addresses on that quiz question /* Which of these interfaces are functional interfaces? */ public interface Adder{ int add(int a, int b); } public interface SmartAdder extends Adder{ int add(double a, double b); } public interface Nothing{ } I know the last one is not, but I think the first and second ones should be functional interface. But the book says second one is not. Why? Doesn't it overrides add method? So even in second, isn't there only one abstract

I've come across many questions in regards of Java8 in-built Functional Interfaces, including this , this , this and this . But all ask about "why only one method?" or "why do I get a compilation error if I do X with my functional interface" and alike. My question is: what is the existential purpose of these new Functional Interfaces, when I can use lambdas anyway in my own interfaces ? Consider the following example code from oracle documentation : // Approach 6: print using a predicate public static void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester) { for (Person p

How can I do something like this in Java 8? boolean x = ((boolean p)->{return p;}).apply(true); Right now I get the following error: The target type of this expression must be a functional interface As per the JLS section 15.27 : It is a compile-time error if a lambda expression occurs in a program in someplace other than an assignment context (§5.2), an invocation context (§5.3), or a casting context (§5.5). It is also possible to use a lambda expression in a return statement . We can then rewrite your example in four different ways: By creating an assignment context: Function<Boolean,

I've come across a strange error message that I believe may be incorrect. Consider the following code: public class Overloaded { public interface Supplier { int get(); } public interface Processor { String process(String s); } public static void load(Supplier s) {} public static void load(Processor p) {} public static int genuinelyAmbiguous() { return 4; } public static String genuinelyAmbiguous(String s) { return "string"; } public static int notAmbiguous() { return 4; } public static String notAmbiguous(int x, int y) { return "string"; } public static int strangelyAmbiguous() { return 4; }

In Java 8 the lambda expression is introduced to help with the reduction of boilerplate code. If the interface has only one method it works fine. If it consists of multiple methods, then none of the methods work. How can I handle multiple methods? We may go for the following example public interface I1() { void show1(); void show2(); } Then what will be the structure of the main function to define the methods in the main itself? Lambda expressions are only usable with functional interface as said by Eran but if you really need multiple methods within the interfaces, you may change the