Introdução às Interfaces Funcionais

Por favor, não trolle muito, estou apenas começando a traduzir artigos

Introdução às Interfaces Funcionais - Conceitos Recriados em Java 8

Todo desenvolvedor Java no mundo já usou uma das seguintes interfaces pelo menos uma vez: java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable. Todos eles têm uma coisa em comum: todos têm apenas um método. Existem muitas outras interfaces desse tipo no JDK, bem como outras criadas por desenvolvedores Java. Essas interfaces também são conhecidas como Single Abstract Method interfaces(interfaces SAM). Uma das maneiras mais populares de usar essas interfaces é criar classes internas anônimas que usam essas interfaces, como no exemplo a seguir:

public class AnonymousInnerClassTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("A thread created and running...");
            }
        }).start();
    }
}

No Java 8, o conceito SAM é recriado e chamado de interfaces funcionais. Eles podem ser representados usando expressões lambda, referências de métodos e construtores de referência. Foi criada uma nova anotação @FunctionalInterface que é usada para lançar erros no nível do compilador quando a interface que você anotou não funciona no nível funcional. Vejamos uma interface funcional simples com um método abstrato:

@FunctionalInterface
public interface SimpleFunInterface {
    public void doWork();
}

Uma interface também pode declarar métodos abstratos de uma classe java.lang.Object, mas neste caso a interface também pode ser declarada funcional:

@FunctionalInterface
public interface SimpleFuncInterface {
    public void doWork();
    public String toString();
    public Boolean equals(Object o);
}

Assim que você adicionar outro método abstrato à interface, o IDE irá marcá-lo como errado, como na imagem: Uma interface pode herdar de outra interface; se a interface herda de uma interface funcional e não contém novos métodos abstratos, então esta interface também é funcional. Mas uma interface pode conter apenas um método abstrato e muitos métodos padrão, e ainda assim será considerada funcional.

@FunctionalInterface
public interface ComplexFunctionalInterface extends SimpleFuncInterface {
    default public void doSomeWork() {
        System.out.println("Doing some work in interface impl...");
    }
    default public void doSomeWork() {
        System.out.println("Doing some other work in interface impl...");
    }
}

O principal exemplo ainda é uma interface funcional. Agora vamos ver como podemos usar expressões lambda para substituir uma classe interna anônima para implementar interfaces funcionais:

/*
*Implementation the interface by creating an
*anonymoous inner class versus using
*lambda expression.
*/
public class SimpleFunInterfaceTest {
    public static void main(String[] args) {
        carryOutWork(new SimpleFunInterface() {
            @Override
            public void doWork() {
                System.out.println("Do work in SimpleFun impl...");
            }
        });
        carryOutWork(() -> System.out.println("Do work in lambda exp impl..."));
    }
    public static void carryOutWork(SimpleFuncInterface sfi) {
        sfi.work();
    }
}

O resultado do programa será o seguinte:

Do work in SimpleFun impl...
Do work in lambda exp impl...

Caso você esteja usando um IDE que suporta sintaxe de expressão Java lambda (compilações Netbeans 8 Nightly) – Você recebe uma dica ao usar classes internas anônimas: Esta foi uma breve introdução ao conceito de interfaces funcionais em Java 8 e como elas podem ser implementadas usando expressões lambda.