refactor(lambda-expression): melhores exemplos

Exemplo de expressão lambda compilando sem a utilização de parênteses.

Alteração da explicação de Type Inference para tentar deixar mais claro.

Issue #20

Author: rinaldodev

book/04-lambda/sections/02-lambda-expression.asc

@@ -104,7 +104,11 @@ Perceba que o compilador identifica que a variável `x3` é alterada no final do
 include::{section-java-package}/lambdaexpression/LambdaExpression_TypeInference.java[tag=code]
 ----
 +
-No exemplo anterior, apenas o método `corra` da interface funcional `Piloto` retorna uma `String`, por isso o compilador sabe que deve chamá-lo.
+No exemplo anterior, apenas o método `run` da interface funcional `Runnable` retorna uma `String`, enquanto o método `execute` da interface funcional `Executavel` não retorna nada (`void`). Isso é diferença suficiente para o compilador saber qual método chamar cada vez que `rode` é invocado.
++ 
+Na primeira chamada ao método `rode`, como a expressão lambda passada retorna uma `String`, o compilador entende que essa expressão lambda é uma implementação da interface `Runnable`, pois o método `run` também retorna uma `String`.
++
+Na segunda chamada ao método `rode`, como a expressão lambda não retorna nada (apenas imprime a `String` `"executando"`), o compilador entende que essa expressão lambda é uma implementação da interface `Executavel`, pois o método `execute` também não retorna nada.
 
 . Se não for possível descobrir o tipo da expressão lambda, ocorre erro de compilação.
 +

src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Parenthesis.java

@@ -16,7 +16,10 @@ public static void main(String[] args) {
     Supplier<Double> elevar2aoQuadrado = -> Math.pow(2, 2);
 
     // COMPILA - parênteses vazios quando não há variáveis
-    Supplier<Double> elevar2aoQuadrado = () -> Math.pow(2, 2);    
+    Supplier<Double> elevar2aoQuadrado = () -> Math.pow(2, 2);
+    
+    // COMPILA - sem parênteses quando há apenas uma variável e não escrevemos seu tipo
+    UnaryOperator<Double> elevarAoQuadrado2 = x -> Math.pow(x, 2);    
     // end::code[]
   }
 }

src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java

@@ -4,28 +4,31 @@ public class LambdaExpression_TypeInference {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor {
-    void corra();
+  interface Executavel {
+    void execute(); // método funcional sem argumentos
   }
 
   @FunctionalInterface
-  interface Piloto {
-    String corra();
+  interface Runnable {
+    String run(); // método funcional também sem argumentos
   }
 
   static class Executor {
-    void execute(Corredor corredor) {
-      corredor.corra();
+    // esse método pode receber uma expressão lambda sem argumentos
+    void rode(Executavel executavel) {
+      executavel.execute();
     }
 
-    String execute(Piloto piloto) {
-      return piloto.corra();
+    // esse método também pode receber uma expressão lambda sem argumentos
+    void rode(Runnable runnable) {
+      runnable.run();
     }
   }
 
   public static void main(String[] args) {
     Executor executor = new Executor();
-    String s = executor.execute(() -> "execute");
+    executor.rode(() -> { return "executando"; }); // irá chamar o execute que recebe um Runnable
+    executor.rode(() -> { System.out.println("executando"); }); // irá chamar o execute que recebe um Executavel
   }
   // end::code[]
 }