• Conceito: Uma referência de método permite referenciar um método sem executá-lo.

• Relação com expressões lambda: Ambas requerem um contexto de tipo de destino composto por uma interface funcional compatível.

• Instância funcional: Uma referência de método cria uma instância de uma interface funcional quando avaliada.

Referências a Métodos Estáticos

• O nome da classe e o método são separados por dois pontos duplos (::), introduzidos no JDK 8.

• Pode ser usada onde for compatível com o tipo de destino.

Exemplo de Referência a Métodos Estáticos

• Interface funcional:
  Nome: IntPredicate
  Método: test(int value)
  Parâmetros: um inteiro.
  Retorno: um booleano (testa condições sobre valores inteiros).

• Classe auxiliar:
  Nome: MyIntPredicates
  Métodos estáticos implementados:
  isPrime(): verifica se o número é primo.
  isEven(): verifica se o número é par.
  isPositive(): verifica se o número é positivo.

• Método principal:
  Nome: numTest()
  Parâmetros:
  Uma referência à interface IntPredicate.
  Um número inteiro a ser testado.

• Execução:
  No método main(), três testes são realizados com numTest().
  Para cada teste, uma referência de método específica (isPrime, isEven, isPositive) é passada como argumento para a execução.

// Demonstra uma referência a um método estático.
// Interface funcional para predicados numéricos que opera com
// valores inteiros.
interface IntPredicate {
boolean test(int n);
}
// Esta classe define três métodos estáticos que verificam um inteiro
// em relação a alguma condição.
class MyIntPredicates {
// Um método estático que retorna true quando um número é primo.
static boolean isPrime(int n) {
if(n < 2) return false;
for(int i=2; i <= n/i; i++) {
if((n % i) == 0)
return false;
}
return true;
}
// Um método estático que retorna true quando um número é par.
static boolean isEven(int n) {
return (n % 2) == 0;
}
// Um método estático que retorna true quando um número é positivo.
static boolean isPositive(int n) {
return n > 0;
}
}
class MethodRefDemo {
// Este método tem uma interface funcional como tipo de seu
// primeiro parâmetro. Logo, pode receber uma referência a
// qualquer instância dessa interface, inclusive uma criada
// por uma referência de método.
static boolean numTest(IntPredicate p, int v) {
return p.test(v);
}
public static void main(String args[])
{
boolean result;
// Aqui, uma referência ao método isPrime é passada para numTest().
result = numTest(MyIntPredicates::isPrime, 17);
if(result) System.out.println("17 is prime.");
// Em seguida, uma referência ao método isEven é usada.
result = numTest(MyIntPredicates::isEven, 12);
if(result) System.out.println("12 is even.");
// Agora, uma referência ao método isPositive é passada.
result = numTest(MyIntPredicates::isPositive, 11);
if(result) System.out.println("11 is positive.");
}
}

• A referência ao método estático isPrime() é passada como argumento para o método numTest().

• O método isPrime() é compatível com a interface funcional IntPredicate.

• A expressão MyIntPredicates::isPrime cria uma referência onde isPrime() implementa o método test() de IntPredicate.

• As outras chamadas a numTest() seguem o mesmo princípio de compatibilidade e funcionamento.

• Qualquer método que tenha a assinatura boolean test(int n) pode ser usado como referência para a interface IntPredicate.