feat(method-reference): melhorias e exemplos

Acrescentado 2 novos exemplos para elucidar melhor a questão, e alterado algumas descrições para ficar mais claro.

Issue #22

Author: rinaldodev

book/04-lambda/sections/04-method-reference.asc

@@ -14,10 +14,14 @@ A sintaxe de referência a um método é uma novidade do Java 8. Com ela é poss
 
 * Referências a métodos estáticos -> `String::valueOf`
 * Referências a métodos de um objeto -> `instanciaDeString::isEmpty`
-* Referências a métodos de um tipo de objeto -> `String::isEmpty`
+* Referências a métodos de um tipo de objeto (de uma classe, interface, etc) -> `String::isEmpty`
 * Referências a construtores -> `String::new`
 
-A seguir serão apresentadas as ocasiões em que cada uma dessas referências é útil.
+É essencial lembrar das Interfaces Funcionais, das variações de sintaxe de Expressões Lambda e das definições de Interfaces Funcionais Pré-Construídas. Caso julgue necessário, reveja as seções deste capítulo.
+
+É possível pensar nas referências a métodos como uma outra forma de escrever uma expressão lambda, caso a única coisa que sua expressão lambda faça seja chamar um outro método.
+
+A seguir serão apresentadas as ocasiões em que são utilizadas as referências a métodos.
 
 . Chamadas a métodos estáticos em expressões lambda podem virar uma referência ao método.
 +
@@ -34,13 +38,15 @@ include::{section-java-package}/methodreference/MethodReference_Static.java[tag=
 5
 ----
 +
-Essa utilização de _method reference_ só é possível porque:
+Nesse caso a única coisa que a expressão lambda faz é receber um argumento `x` e repassar para o método `valueOf` de `String`. Para simplificar isso, o Java 8 permite que você escreva essa mesma função lambda como foi apresentado na linha seguinte: `String::valueOf`.
 +
-* A implementação de `String.valueOf(int)` satisfaz a interface funcional `Function` (recebe um argumento e retorna um valor).
+Só é possível representar a primeira expressão lambda na forma de um _method reference_ porque:
++
+* A implementação de `String.valueOf` satisfaz a interface funcional `Function` (recebe um argumento e retorna um valor).
 * O argumento de entrada da expressão lambda `x` é exatamente o mesmo passado para o método `String.valueOf(x)`.
-* Essa é a única chamada que essa expressão lambda faz.
+* A expressão lambda é simples: somente possui uma chamada a um método.
 
-. Chamadas a métodos de uma instância também podem ser representados como uma referência a um método.
+. Chamadas a métodos de uma instância específica também podem ser representados como uma referência a um método.
 +
 [source,java,indent=0]
 .{java-package}/methodreference/MethodReference_Instance.java
@@ -55,13 +61,13 @@ include::{section-java-package}/methodreference/MethodReference_Instance.java[ta
 5 - 8
 ----
 +
-Essa utilização de _method reference_ só é possível porque:
+Só é possível representar a primeira expressão lambda na forma de um _method reference_ porque:
 +
 * A implementação de `Conversor.converte(Integer, Integer)` satisfaz a interface funcional `BiFunction` (recebe dois argumentos e retorna um valor).
 * Os argumentos de entrada da expressão lambda `x` e `y` são exatamente os mesmos passados para o método `Conversor.converte(Integer, Integer)`.
-* Essa é a única chamada que essa expressão lambda faz.
+* A expressão lambda é simples: somente possui uma chamada a um método.
 
-. Chamadas a métodos de um tipo específico, sem especificar a instância, também podem ser representados como uma referência a um método.
+. Chamadas a métodos de uma classe, sem especificar a instância específica, também podem ser representados como uma referência a um método.
 +
 [source,java,indent=0]
 .{java-package}/methodreference/MethodReference_Type.java
@@ -76,11 +82,11 @@ include::{section-java-package}/methodreference/MethodReference_Type.java[tag=co
 8.0
 ----
 +
-Nesse exemplo, a referência está sendo feita ao método `doubleValue` do *tipo* `Integer`. Essa utilização de _method reference_ só é possível porque:
+Nesse exemplo, a referência está sendo feita ao método `doubleValue` do *tipo* `Integer`. Só é possível representar a primeira expressão lambda na forma de um _method reference_ porque:
 +
-* Nossa expressão lambda satisfaz a interface funcional `Function` (recebe um argumento e retorna um valor).
+* Nossa expressão lambda satisfaz a interface funcional `Function` (recebe um argumento `x` e retorna um valor `double`).
 * A expressão lambda recebe um argumento `x` do tipo `Integer`, que possui o método `doubleValue` que não recebe parâmetros.
-* Essa é a única chamada que essa expressão lambda faz.
+* A expressão lambda é simples: somente possui uma chamada a um método.
 
 . Também é possível utilizar a referência ao método de um tipo, como no exemplo anterior, mesmo que o método receba parâmetros.
 +
@@ -126,6 +132,24 @@ include::{section-java-package}/methodreference/MethodReference_Complex.java[tag
 +
 Como nesse caso temos uma outra `String` `+ "2"` sendo acrescentada no construtor, não há como representar isso com uma simples referência ao construtor.
 
+. É possível utilizar _method reference_ também com suas própria classes. Veja no exemplo a seguir os tipos criados pelo nosso código e as expressões lambda equivalentes com e sem referência a métodos.
++
+[source,java,indent=0]
+.{java-package}/methodreference/MethodReference_CustomType.java
+----
+include::{section-java-package}/methodreference/MethodReference_CustomType.java[tag=code]
+----
+
+. A variedade de formas para representar uma mesma expressão lambda pode ser grande, então cuidado para não se confundir.
++
+[source,java,indent=0]
+.{java-package}/methodreference/MethodReference_Variaty.java
+----
+include::{section-java-package}/methodreference/MethodReference_Variaty.java[tag=code]	
+----
++
+Você já viu todas as formas de criar uma expressão lambda, desde a mais completa até a mais simples. Tenha certeza que conhece todas essas variações para o exame de certificação.
+
 .Referências
 ****
 

src/org/j6toj8/lambda/methodreference/MethodReference_CustomType.java

@@ -0,0 +1,50 @@
+package org.j6toj8.lambda.methodreference;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class MethodReference_CustomType {
+
+  // tag::code[]
+  static class SuperHeroi {
+    private Pessoa pessoa;
+
+    public SuperHeroi(Pessoa pessoa) {
+      this.pessoa = pessoa;
+    }
+    
+    public static SuperHeroi crieSuperHeroi(Pessoa pessoa) {
+      return new SuperHeroi(pessoa);
+    }
+    
+  }
+  
+  static class Pessoa {
+    
+    public SuperHeroi vireSuperHeroi() {
+      return new SuperHeroi(this);
+    }
+    
+  }
+  
+  public static void main(String[] args) {
+    // expressões lambda equivalentes utilizando chamada a método estático
+    Function<Pessoa, SuperHeroi> transformaEmHeroiStatic1 = p -> SuperHeroi.crieSuperHeroi(p);
+    Function<Pessoa, SuperHeroi> transformaEmHeroiStatic2 = SuperHeroi::crieSuperHeroi;
+    
+    // expressões lambda equivalentes utilizando construtor
+    Function<Pessoa, SuperHeroi> transformaEmHeroiConstrutor1 = p -> new SuperHeroi(p);
+    Function<Pessoa, SuperHeroi> transformaEmHeroiConstrutor2 = SuperHeroi::new;
+    
+    // expressões lambda equivalentes utilizando chamada de método comum, mas referenciando o método da classe
+    Function<Pessoa, SuperHeroi> transformaEmHeroiClasse1 = p -> p.vireSuperHeroi();
+    Function<Pessoa, SuperHeroi> transformaEmHeroiClasse2 = Pessoa::vireSuperHeroi;
+    
+    // expressões lambda equivalentes utilizando chamada de método comum, mas referenciando o método do objeto
+    Pessoa pessoa = new Pessoa();
+    Supplier<SuperHeroi> transformaEmHeroiInstancia1 = () -> pessoa.vireSuperHeroi();
+    Supplier<SuperHeroi> transformaEmHeroiInstancia2 = pessoa::vireSuperHeroi;
+  }
+  // end::code[]
+  
+}

src/org/j6toj8/lambda/methodreference/MethodReference_Type.java

@@ -8,7 +8,7 @@ public static void main(String[] args) {
     // tag::code[]
     // representação com expressão lambda
     Function<Integer, Double> intParaDouble1 = x -> x.doubleValue();
-    // representação com referência ao método d
+    // representação com referência ao método doubleValue
     Function<Integer, Double> intParaDouble2 = Integer::doubleValue;
 
     // os resultados serão iguais

src/org/j6toj8/lambda/methodreference/MethodReference_Variaty.java

@@ -0,0 +1,23 @@
+package org.j6toj8.lambda.methodreference;
+
+import java.util.function.Function;
+
+public class MethodReference_Variaty {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // ATENÇÃO! Todas essas expressões lambda são equivalentes!
+    
+    Function<Integer, String> lambda1 = (Integer x) -> { return String.valueOf(x); };
+    Function<Integer, String> lambda2 = (x) -> { return String.valueOf(x); };
+    Function<Integer, String> lambda3 = x -> { return String.valueOf(x); };
+    
+    Function<Integer, String> lambda4 = (Integer x) -> String.valueOf(x);
+    Function<Integer, String> lambda5 = (x) -> String.valueOf(x);
+    Function<Integer, String> lambda6 = x -> String.valueOf(x);
+    
+    Function<Integer, String> lambda7 = String::valueOf;
+    // end::code[]
+  }
+  
+}