11.5. How to Create Lambda Expressions¶

The easiest way to create a lambda expression is by pretending to assign your intended method override to a variable of the interface type. Here's an example:

Assign your intended method override to a variable of the interface type:
Listing 11.9 This won't compile, but it's a good way to get started¶
```
Consumer<String> shout = @Override public void accept(String t) {
    return System.out.println(t.toUpperCase());
};
```
Remove the annotation (@Override), the visibility modifier (public), the return type (void) and the method name (accept):
Listing 11.10 this still won't compile, but it's only two characters away from working¶
```
Consumer<String> shout = (String t) {
    System.out.println(t.toUpperCase());
};
```
Add an arrow (->) between the parameter list and the opening curly brace:
Listing 11.11 this WILL compile; we provided a valid lambda expression!¶
```
Consumer<String> shout = (String t) -> {
    System.out.println(t.toUpperCase());
};
```

Notice that the parameter above has type String. When we write the parameter types explicitly, they must match the parameter types of the functional interface's abstract method after substituting its type arguments. For Consumer<String>, the parameter of accept has type String. Writing Object t instead would not work, even though Object is a superclass of String.

Let's apply this to another interface that we will use with JavaFX. EventHandler<T> declares void handle(T event). For EventHandler<ActionEvent>, that parameter has type ActionEvent:

EventHandler<ActionEvent> h1 = (ActionEvent event) -> { }; // valid
EventHandler<ActionEvent> h2 = event -> { };               // valid: inferred

The following alternatives do not compile in a context where T has not been declared as a type:

EventHandler<ActionEvent> h3 = (Event event) -> { }; // wrong parameter type
EventHandler<ActionEvent> h4 = (T event) -> { };     // T is not declared

The type arguments of an interface do not tell us how many parameters its abstract method has. For example, Function<String, Integer> has one parameter of type String and a result type of Integer. A lambda expression for it might be text -> text.length(). The int result of length is boxed to Integer; it is not a second parameter. Inspect the abstract method's declaration when you are unsure which parameters to write.

Test Yourself

Use a lambda expression to create a consumer that prints the length of a string.
Use a lambda expression to create a consumer that prints the number of exclamation marks in a string.
Use a lambda expression to create a discount strategy that reduces the original price by 25% and subtracts an additional five dollars (if the item is not below five dollars already).