Uma importante construção introduzida no Java 8, juntamente com as expressões lambda, foi a definição de referências para métodos ou construtores. Uma referência para método é uma indicação de que um método existente em outra classe deve ser utilizado num ponto específico do código, sendo que este mecanismo também é válido para construtores.
Para que seja possível o uso de uma referência de método, o target-type (tipo-alvo) do método deve ser compatível com aquele requerido no local da referência e também previamente estabelecido por meio da declaração de uma interface funcional. Como visto no artigo anterior, sobre expressões lambda, o target-type é a combinação das informações relativas ao tipo de retorno da expressão lambda, seguida da lista dos tipos de seus parâmetros entre parêntesis.
Por conta da compatibilidade exigida entre o target-type requerido e a referência de método utilizada, é possível utilizar uma referência de método no local onde uma expressão lambda é aceita e também o inverso, ou seja, usar uma expressão lambda para substituir uma referência de método. Assim, o uso de referências para métodos é útil para evitar a redefinição de métodos existentes em outras classes, ao mesmo tempo que não interfere na possibilidade de uso de expressões lambda.
Existem quatro tipos diferentes de referências para métodos, cuja sintaxe é um pouco diferente: referências para métodos estáticos; referências para métodos de instância de objeto específico; referências para métodos de instância de objeto arbitrário de tipo; e referências para construtores.
Referências para métodos estáticos
O tipo mais simples de referência para método é aquela para um método estático com visibilidade pública, cuja sintaxe é:
NomeClasse::metodoEstatico
Em que NomeClasse é o nome da classe e metodoEstatico é o nome do método. Tomando a classe Math como exemplo, observam-se vários métodos estáticos cujo target-type é double (double), tais como cbrt, exp e log. Todos estes métodos são compatíveis com algumas das interfaces predefinidas no pacote java.util.function, no caso DoubleUnaryOperator, DoubleFunction<T> e Function<T,V>. Isto permite declarar referências para métodos de target-type específicos como:
DoubleUnaryOperator f_cbrt = Math::cbrt;
DoubleFunction<Double> f_exp = Math::exp;
Function<Double,Double> f_log = Math::log;
Já os métodos max, mix e pow, também da classe Math, possuem um target-type double (double, double) e podem ser referenciados como Math::max, Math::min e Math::pow:
DoubleBinaryOperator f_max = Math::max;
BinaryOperator<Double> f_min = Math::min;
Calculavel f_pow = Math::pow;
Deve-se observar que toda referência para método possui uma expressão lambda equivalente (de mesmo target-type):
DoubleUnaryOperator f_cbrt2 = (v) -> Math.cbrt(v);
BinaryOperator<Double> f_min2 = (a, b) -> Math.min(a, b);
Embora exista tal equivalência, é importante notar que o uso da referência para método exige o acionamento do método declarado pela interface funcional e não do método referenciado. Assim, a referência f_max, declarada anteriormente como do tipo DoubleBinaryOperator, deve ser acionada pelo método applyAsDouble(double, double) declarado nesta interface. Da mesma maneira f_cbrt, do tipo DoubleUnaryOperator, deve ser acionado pelo método applyAsDouble(double).
O exemplo que segue mostra o uso direto de referências para métodos estáticos.
/* Arquivo: RefMetEstatico.java
*/
package jandl.j8r;
import java.util.function.*;
public class RefMetEstatico {
public static void main(String[] args) {
// Uso direto dos métodos da classe Math
System.out.println("cbrt(27.0)=" + Math.cbrt(27.0));
System.out.println("exp(1.0)=" + Math.exp(1.0));
System.out.println("max(2.0, 1.5)=" + Math.max(2.0, 1.5));
System.out.println("min(2.0, 1.5)=" + Math.min(2.0, 1.5));
// Referências de métodos com assinatura double (double)
DoubleUnaryOperator f_cbrt = Math::cbrt;
DoubleFunction<Double> f_exp = Math::exp;
// Referências de métodos com assinatura
// double (double, double)
DoubleBinaryOperator f_max = Math::max;
BinaryOperator<Double> f_min = Math::min;
// Uso das referências de métodos
System.out.println("cbrt(27.0)=" +
f_cbrt.applyAsDouble(27.0));
System.out.println("exp(1.0)=" +
f_exp.apply(1.0));
System.out.println("max(2.0, 1.5)=" +
f_max.applyAsDouble(2.0, 1.5));
System.out.println("min(2.0, 1.5)=" +
f_min.apply(2.0, 1.5));
// Expressões lambda equivalentes
DoubleUnaryOperator f_cbrt2 = v -> Math.cbrt(v);
BinaryOperator<Double> f_min2 = (a, b) -> a < b ? a : b;
// Uso das referências (de métodos) para expressões lambda
System.out.println("cbrt2(729)=" +
f_cbrt2.applyAsDouble(729));
System.out.println("min2(2.0, 1.5)=" +
f_min2.apply(2.0, 1.5));
}
}
Este programa produz o resultado que segue, onde é possível verificar que o uso das referências e suas expressões lambda equivalentes produzem os mesmos resultados.
cbrt(27.0)=3.0
exp(1.0)=2.718281828459045
max(2.0, 1.5)=2.0
min(2.0, 1.5)=1.5
cbrt(27.0)=3.0
exp(1.0)=2.718281828459045
max(2.0, 1.5)=2.0
min(2.0, 1.5)=1.5
cbrt2(729)=9.0
min2(2.0, 1.5)=1.5
Referências para métodos de instância de objetos específicos
A sintaxe para uma referência para um método de instância (de objeto) com visibilidade pública é:
objeto::metodoInstancia
Aqui objeto é uma referência válida (não nula) para uma instância disponível no escopo e metodoInstancia é o nome do método público referenciado. Consideremos, por exemplo, a classe Resistor, que representa um resistor segundo a lei de Ohm.
/* Arquivo: Resistor.java
*/
package jandl.j8r;
public class Resistor {
protected double resistencia;
public Resistor(double resistencia) {
setResistencia(resistencia);
}
public double getResistencia() {
return resistencia;
}
public void setResistencia(double resistencia) {
if (resistencia <= 0) {
throw new RuntimeException("Resistência inválida: " +
resistencia);
}
this.resistencia = resistencia;
}
public double correnteParaTensao(double tensao) {
return tensao / resistencia;
}
public double tensaoParaCorrente(double corrente) {
return resistencia * corrente;
}
@Override
public String toString() {
return String.format("R:%7.1fOhms", resistencia);
}
}
Esta classe dispõe de alguns métodos de instância, como getResistencia(), setResistencia(double), correnteParaTensao(double) e tensaoParaCorrente(double). Uma instância desse tipo, denominada r10k, pode ser obtida com:
Resistor r10k = new Resistor(10000);
Dessa maneira, seus métodos de instância podem ser referenciados como:
r10K::getResistencia
r10K::setResistencia
r10K::correnteParaTensao
r10K::tensaoParaCorrente
O exemplo que segue mostra como referências para métodos de instância permitem a manipulação indireta de um objeto. Como antes, as interfaces funcionais predefinidas existentes no pacote java.util.function simplificam a programação, evitando a definição de interfaces específicas. Foram usadas as interfaces DoubleConsumer, DoubleFunction<T> e DoubleSupplier.
/* Arquivo: RefMetInstancia.java
*/
package jandl.j8r;
import java.util.function.DoubleConsumer;
import java.util.function.DoubleFunction;
import java.util.function.DoubleSupplier;
public class RefMetInstancia {
public static void main(String[] args) {
// Instanciação de objeto tipo Resistor
Resistor resistor = new Resistor(10000);
System.out.println("Resistência : " + resistor);
// Referências para métodos da instância r10k
DoubleSupplier get_resistencia = resistor::getResistencia;
DoubleConsumer set_resistencia = resistor::setResistencia;
DoubleFunction<Double> i_V = resistor::correnteParaTensao;
DoubleFunction<Double> v_I = resistor::tensaoParaCorrente;
// Manipulação da instância via referências para métodos
System.out.println("Resistência : " +
get_resistencia.getAsDouble());
System.out.println("i para V=12V: " +
i_V.apply(12));
System.out.println("v para i=0.001A: " +
v_I.apply(0.001));
set_resistencia.accept(1000);
System.out.println("Nova Resistência : " + resistor);
System.out.println("Resistência : " +
get_resistencia.getAsDouble());
System.out.println("i para V=12V: " +
i_V.apply(12));
System.out.println("v para i=0.001A: " +
v_I.apply(0.001));
}
}
Este programa produz o resultado seguinte que ilustra como referências para métodos podem manipular um objeto específico.
Resistência : R:10000,0Ohms
Resistência : 10000.0
i para V=12V: 0.0012
v para i=0.001A: 10.0
Nova Resistência : R: 1000,0Ohms
Resistência : 1000.0
i para V=12V: 0.012
v para i=0.001A: 1.0
Deve ser destacado que as referências para métodos de instância somente afetam o objeto especificamente referenciado. Como antes, estas referências também são equivalentes a expressões lambda, como segue:
DoubleSupplier get_resistencia_2 = () -> r10k.getResistencia();
DoubleConsumer set_resistencia_2 = (r) -> r10k.setResistencia(r);
DoubleFunction<Double> i_V_2 = (v) -> r10k.correnteParaTensao(v);
DoubleFunction<Double> v_I_2 = (i) -> r10k.tensaoParaCorrente(i);
Referências para métodos de instância de objetos arbitrários
Outra possibilidade para utilização das referências para métodos é quando se deseja acionar um método com visibilidade pública para quaisquer objetos de um tipo específico. Neste caso a sintaxe das referências para métodos é:
NomeClasse::metodoInstancia
Aqui NomeClasse indica o nome da classe/tipo que contém o metodoInstancia, cujo acionamento é desejado para qualquer instância, ou seja, para objetos arbitrários.
Como é bastante comum a necessidade de ordenar-se um conjunto de objetos de um tipo particular, existe neste problema uma situação de uso conveniente das referências para métodos. Vários objetos da classe Resistor, definida anteriormente, poderiam ser armazenados em um array como segue:
Resistor[] resistorArray = {
new Resistor(1234), new Resistor(23456),
new Resistor(345), new Resistor(67),
new Resistor(879), new Resistor(1098),
new Resistor(543) };
Caso fosse necessário ordenar os elementos deste array de objetos tipo Resistor, poderia ser utilizado o método sort (T[], Comparator<T>), da classe Arrays, o qual toma como argumentos o array a ser ordenado e um comparador adequado. Assim a solução convencional seria construir uma classe dotada da interface Comparator<T> para suprir o comparador necessário, ou seja, uma classe cuja implementação contenha o método compare (T a, T b) destinado à comparar objetos para possibilitar sua ordenação.
/* Arquivo: ResistorComparator.java
*/
package jandl.j8r;
import java.util.Comparator;
// Comparador específico para objetos Resistor
public class ResistorComparator implements Comparator<Resistor> {
@Override
public int compare(Resistor a, Resistor b) {
return (int) (a.getResistencia() - b.getResistencia());
}
}
Desta maneira, o array resistorArray pode ser ordenado com:
Arrays.sort(resistorArray, new ResistorComparator());
Outra opção, mais simples, seria utilizar uma expressão lambda para suprir a operação de comparação, pois Comparator<T> é uma interface funcional.
Arrays.sort(resistorArray,
(Resistor a, Resistor b) —> (int) (a.getResistencia() -
b.getResistencia()));
Uma outra opção seria incluir um método estático, como este que segue, capaz de efetuar a comparação de dois objetos do tipo Resistor, na própria classe Resistor.
public static int comparador(Resistor a, Resistor b) {
return (int) (a.getResistencia() - b.getResistencia());
}
Como o target-type desse método é a mesmo da expressão lambda usada na ordenação do array, i.e., int (Resistor, Resistor), é possível realizar a ordenação do array de tipos Resistor com:
Arrays.sort(resistorArray, Resistor::comparador);
Nessa alternativa, muito compacta, foi usada uma referência para método estático. Mas a adição de um método de instância na classe Resistor para realizar a comparação também é uma opção a ser considerada e que pode ser obtida com:
public int comparador2(Resistor b) {
return (int) (this.getResistencia() - b.getResistencia());
}
Embora a assinatura deste métodos seja int (Resistor), sua semântica, de fato é int (Resistor, Resistor), pois uma expressão lambda equivalente teria de capturar duas referências do tipo Resistor para computar o resultado de sua expressão (a autorreferência this e o argumento b), de modo que seu target-type efetivo seja int (Resistor, Resistor), a mesma da interface funcional Comparator<T> necessária para ordenação do array, permitindo escrever:
Arrays.sort(resistorArray, Resistor::comparador2);
Esta última opção mostra uma referência para um método de instância indicada por meio de sua classe (e não por um objeto), o que implicitamente adiciona um argumento do mesmo tipo ao método (que corresponde a autorreferência). Assim, esta situação considera o primeiro argumento da expressão lambda como instância a partir da qual se invoca o método, tornando possível seu uso para quaisquer pares de objetos do tipo, implicando no target-type tipoRetorno (Tipo, Tipo).
O próximo exemplo ilustra essas várias alternativas. Utilizando cópias do array resistorArray, obtidas com uso do método clone(), a primeira operação de ordenação emprega uma instância de ResistorComparator, classe que é uma implementação específica de comparador para objetos do tipo Resistor. A segunda operação de ordenação, destacada na sequência, utiliza uma expressão lambda, opção concisa que elimina a necessidade da implementação de um comparador. A terceira ordenação é realizada com uso de uma referência o método estático comparador da classe Resistor. A quarta operação de ordenação emprega uma referência para método de instância comparador2 do tipo Resistor. As duas últimas alternativas se mostram muito mais concisas que as primeiras, embora só possam ser utilizadas quando se dispõem de métodos convenientes para serem referenciados.
/* Arquivo: RefMetTipo.java
*/
package jandl.j8r;
import java.util.Arrays;
public class RefMetTipo {
public static void main(String[] args) throws Exception {
// Array de resistores
Resistor[] resistorArray = {
new Resistor(1234), new Resistor(23456),
new Resistor(345), new Resistor(67),
new Resistor(879), new Resistor(1098),
new Resistor(543) };
Resistor[] copia;
System.out.println("0:" + Arrays.toString(resistorArray));
// Ordenação do array com comparator específico
copia = resistorArray.clone();
Arrays.sort(copia, new ResistorComparator());
System.out.println("1:" + Arrays.toString(copia));
// Ordenação do array com expressão lambda
copia = resistorArray.clone();
Arrays.sort(copia, (Resistor a, Resistor b) ->
(int) (a.getResistencia() - b.getResistencia()));
System.out.println("2:" + Arrays.toString(copia));
// Ordenação do array com referência para método estático
copia = resistorArray.clone();
Arrays.sort(copia, Resistor::comparador);
System.out.println("3:" + Arrays.toString(copia));
// Ordenação do array com referência para
// método de instância de tipo
copia = resistorArray.clone();
Arrays.sort(copia, Resistor::comparador2);
System.out.println("4:" + Arrays.toString(copia));
}
}
Quando executado este exemplo produz o resultado apresentado abaixo, onde se observa que todas as alternativas de ordenação apresentam o mesmo resultado, mostrando a conveniência de expressões lambda e referências de métodos para simplificar a definição de comparadores:
0:[R: 1234,0Ohms, R:23456,0Ohms, R: 345,0Ohms,
R: 67,0Ohms, R: 879,0Ohms, R: 1098,0Ohms, R: 543,0Ohms]
1:[R: 67,0Ohms, R: 345,0Ohms, R: 543,0Ohms,
R: 879,0Ohms, R: 1098,0Ohms, R: 1234,0Ohms, R:23456,0Ohms]
2:[R: 67,0Ohms, R: 345,0Ohms, R: 543,0Ohms,
R: 879,0Ohms, R: 1098,0Ohms, R: 1234,0Ohms, R:23456,0Ohms]
3:[R: 67,0Ohms, R: 345,0Ohms, R: 543,0Ohms,
R: 879,0Ohms, R: 1098,0Ohms, R: 1234,0Ohms, R:23456,0Ohms]
4:[R: 67,0Ohms, R: 345,0Ohms, R: 543,0Ohms,
R: 879,0Ohms, R: 1098,0Ohms, R: 1234,0Ohms, R:23456,0Ohms]
Referências para construtores
O último tipo de referências para métodos é voltado para o uso de construtores, cuja sintaxe é semelhante à criação de referências para métodos estáticos:
NomeClasse::new
É claro que o NomeClasse indica a classe cujos construtores se deseja referenciar com a indicação de new. Quando existem múltiplos construtores, o compilador infere aquele de será usado efetivamente considerando o contexto de uso da referência. Para especificar a instanciação de arrays, basta acrescentar um par de colchetes após a indicação do tipo:
NomeClasse[]::new
Desta maneira String::new referencia um construtor da classe String, enquanto String[]::new é adequado para referenciar a construção de um array de objetos do tipo String.
Segue um exemplo que ilustra maneiras diferentes para instanciar um objeto de tipo específico: a primeira por meio de instanciação explícita; a segunda por meio de um método fábrica (um padrão de projeto útil); e a terceira pela combinação do uso de uma interface funcional com uma referência para construtor compatível.
/* Arquivo: RefMetConstrutor.java
*/
package jandl.j8r;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
public class RefMetConstrutor {
// Método fábrica de listas de objetos do tipo T
public static <T> List<T> createList() {
return new ArrayList<T>();
}
// Supplier de listas<Resistor>
public static Supplier<List<Resistor>> resistorListFactory =
ArrayList<Resistor>::new;
public static void main(String[] args) throws Exception {
// Obtenção explícita de lista
List<Long> lista1 = new ArrayList<Long>();
// Obtenção de lista com fábrica com inferência de tipo
List<Long> lista2 = RefMetConstrutor.createList();
// Obtenção de lista com Supplier
List<Resistor> lista3 =
RefMetConstrutor.resistorListFactory.get();
// Uso das listas
lista1.add(123456789L);
lista1.add(135791113L);
lista2.addAll(lista1);
lista2.add(2468101214L);
lista3.add(new Resistor(10));
lista3.add(new Resistor(360));
lista3.add(new Resistor(4700));
lista3.add(new Resistor(82000));
// Exibição das listas
System.out.println("Lista1: " + lista1);
System.out.println("Lista2: " + lista2);
System.out.println("Lista3: " + lista3);
}
}
Este exemplo produz o resultado que segue, onde as listas exibidas mostram os elementos adicionados corretamente.
Lista1: [123456789, 135791113]
Lista2: [123456789, 135791113, 2468101214]
Lista3: [R: 10,0Ohms, R: 360,0Ohms, R: 4700,0Ohms, R:82000,0Ohms]
O uso da referência para construtor permite alguma simplificação do código necessário, embora o método fábrica genérico seja mais flexível devido à possível parametrização de tipos. Também deve ser observado que a referência para construtor é, como antes, equivalente a uma expressão lambda, como esta:
public static Supplier<List<Long>> listFactory =
() -> new ArrayList<Long>();
Considerações finais
No Java 8 tornou-se possível o uso de referências para métodos existentes no lugar de expressões lambda, desde que suas assinaturas sejam compatíveis. Isto constitui uma alternativa interessante que, em muitos casos, permite substituir o uso de instâncias de classes auxiliares, instâncias de classes anônimas e até mesmo expressões lambda pela indicação de métodos e construtores disponíveis, reduzindo a quantidade de código necessária, simplificando o desenvolvimento de aplicações.
Como para as expressões lambda, as substituições possíveis dependem da existência de interfaces funcionais compatíveis, onde a API do Java 8 contribui significativamente aos oferecer muitas interfaces funcionais de propósito geral no pacote java.util.function que podem servir de target-type para lambdas e referências de métodos.
Este artigo faz parte de uma pequena série:
