feat(functional-interfaces): novos exemplos

Criação de dois novos exemplos para mostrar: que o retorno nem sempre precisa ser void; que é possível implementar uma interface funcional com uma classe, mesmo que não seja feito para ser utilizado dessa forma.

Alteração dos exemplos anteriores para uma interface que faz mais sentido de ser funcional: Executavel (parecida com Runnable do Java).

Issue #19

Author: rinaldodev

book/04-lambda/sections/01-functional-interfaces.asc

@@ -10,6 +10,8 @@ Define and write functional interfaces and describe the interfaces of the java.u
 Definir e escrever interfaces funcionais e descrever as interfaces do pacote java.util.function.
 --------------------------------------------------
 
+Interfaces funcionais são um novo tipo de Interface do Java. Aqui serão apresentados os conceitos. Na seção de Expressões Lambda será possível ver como utilizá-las.
+
 . Interfaces Funcionais são aquelas que possuem apenas um método abstrato, chamado de "método funcional".
 . É recomendada a utilização da anotação @FunctionalInterface, mas não obrigatório.
 +
@@ -69,6 +71,24 @@ include::{section-java-package}/functionalinterfaces/FunctionalInterfaces_Interf
 include::{section-java-package}/functionalinterfaces/FunctionalInterfaces_ClassCompilationError.java[tag=code]
 ----
 
+. Os métodos funcionais podem ter qualquer tipo de retorno.
++
+[source,java,indent=0]
+.{java-package}/functionalinterfaces/FunctionalInterfaces_ReturnType.java
+----
+include::{section-java-package}/functionalinterfaces/FunctionalInterfaces_ReturnType.java[tag=code]
+----
+
+. Interfaces funcionais são feitas com o intuito de serem utilizadas em expressões lambda, mas o código também irá compilar normalmente caso uma classe a implemente.
++
+[source,java,indent=0]
+.{java-package}/functionalinterfaces/FunctionalInterfaces_Implement.java
+----
+include::{section-java-package}/functionalinterfaces/FunctionalInterfaces_Implement.java[tag=code]
+----
++
+Esse é apenas um exemplo para você saber que essa implementação não gera erro de compilação, mas *não* utilize interfaces funcionais dessa forma. Na seção de Expressões Lambda você verá como as interfaces funcionais devem ser utilizadas na prática.
+
 ==== Interfaces Funcionais do pacote `java.util.function`
 
 As interfaces descritas aqui estão disponíveis no pacote `java.util.function`. Nesta seção serão apresentadas apenas suas definições, pois há posteriormente uma seção específica para tratar dos exemplos de cada uma.

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_Basic.java

@@ -4,8 +4,8 @@ public class FunctionalInterfaces_Basic {
 
   // tag::code[]
   @FunctionalInterface // a anotação não é obrigatória
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
   }
   // end::code[]
 }

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_ClassCompilationError.java

@@ -4,12 +4,12 @@ public class FunctionalInterfaces_ClassCompilationError {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
   }
 
   @FunctionalInterface
-  class Piloto implements Corredor { // NÃO COMPILA!
+  class Piloto { // NÃO COMPILA!
     // apenas interfaces podem ser anotadas com @FunctionalInterface
   } 
   // end::code[]

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_DefaultStatic.java

@@ -4,19 +4,20 @@ public class FunctionalInterfaces_DefaultStatic {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
 
     // métodos adicionais static são permitidos
-    static void corram(Corredor... corredores) {
-      for (Corredor corredor : corredores) {
-        corredor.corra();
+    static void execute(Executavel... executaveis) {
+      for (Executavel executavel : executaveis) {
+        executavel.execute();
       }
     }
 
     // métodos adicionais default são permitidos
-    default String pule() {
-      return "Corredor pulando";
+    default void executeDuasVezes() {
+      execute();
+      execute();
     }
   }
   // end::code[]

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_Extends.java

@@ -4,12 +4,12 @@ public class FunctionalInterfaces_Extends {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
   }
 
   @FunctionalInterface
-  interface Piloto extends Corredor {
+  interface Aplicacao extends Executavel {
     // também é uma interface funcional
   } 
   // end::code[]

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_ExtendsNewMethod.java

@@ -4,13 +4,13 @@ public class FunctionalInterfaces_ExtendsNewMethod {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
   }
 
-  interface Piloto extends Corredor {
-    // NÃO é uma interface funcional, pois possui 2 métodos abstratos: corra (herdado) e pilote.
-    void pilote();
+  interface Aplicacao extends Executavel {
+    // NÃO é uma interface funcional, pois possui 2 métodos abstratos: execute (herdado) e inicie.
+    void inicie();
   } 
   // end::code[]
 }

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_Implement.java

@@ -0,0 +1,22 @@
+package org.j6toj8.lambda.functionalinterfaces;
+
+public class FunctionalInterfaces_Implement {
+
+  // tag::code[]
+  @FunctionalInterface
+  interface Executavel { // interface funcional
+    String execute(); // método funcional
+  }
+  
+  class Pessoa implements Executavel {
+    // COMPILA!
+    // interfaces funcionais, como Corredor, não foram feitas para serem implementadas dessa forma
+    // porém é possível e o código compila normalmente
+    @Override
+    public String execute() {
+      return "Executando";
+    }
+  }
+  // end::code[]
+  
+}

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_InterfaceCompilationError.java

@@ -4,14 +4,14 @@ public class FunctionalInterfaces_InterfaceCompilationError {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
   }
 
   @FunctionalInterface
-  interface Piloto extends Corredor { // NÃO COMPILA!
+  interface Aplicacao extends Executavel { // NÃO COMPILA!
     // não pode ser anotada como funcional, pois possui 2 métodos abstratos
-    void pilote();
+    void inicie();
   } 
   // end::code[]
 }

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_OverrideObject.java

@@ -4,8 +4,8 @@ public class FunctionalInterfaces_OverrideObject {
 
   // tag::code[]
   @FunctionalInterface
-  interface Corredor { // interface funcional
-    void corra(); // método funcional
+  interface Executavel { // interface funcional
+    void execute(); // método funcional
 
     // sobrescrevendo métodos de Object
     @Override

src/org/j6toj8/lambda/functionalinterfaces/FunctionalInterfaces_ReturnType.java

@@ -0,0 +1,11 @@
+package org.j6toj8.lambda.functionalinterfaces;
+
+public class FunctionalInterfaces_ReturnType {
+
+  // tag::code[]
+  @FunctionalInterface
+  interface Executavel { // interface funcional
+    String execute(); // método funcional com retorno
+  }
+  // end::code[]
+}