Olá, Leonardo
Tudo bem?
Você está certo ao pensar que tem relação com a interface de um método só. Isso é o que chamamos de "interface funcional" em Java. Interfaces funcionais podem ser usadas como alvos para expressões lambda e referências de método.
No seu caso, a interface ServiceFactory<T> é uma interface funcional porque tem apenas um método abstrato: create(). Aqui está a definição da interface para relembrar:
public interface ServiceFactory<T> {
ConsumerService<T> create();
}
Quando você passa EmailService::new para o construtor de ServiceRunner, você está passando uma referência de método que corresponde ao método create() da interface ServiceFactory<T>.
O que isso significa na prática é que EmailService::new é uma referência ao construtor de EmailService. Então, quando o método create() for chamado, ele vai criar uma nova instância de EmailService.
Aqui está como isso se encaixa no código que você forneceu:
new ServiceRunner(EmailService::new).start(5);
public ServiceRunner(ServiceFactory<T> factory) {
this.provider = new ServiceProvider<>(factory);
}
Quando você faz new ServiceRunner(EmailService::new), você está dizendo que ServiceFactory<T> deve usar o construtor de EmailService para criar novas instâncias. O tipo genérico T é inferido automaticamente pelo compilador com base no contexto em que ServiceFactory é usado.
Para deixar mais claro, aqui está um exemplo prático:
public class EmailService implements ConsumerService<String> {
// Construtor
public EmailService() {
// Inicialização
}
// Implementação dos métodos de ConsumerService
}
public class Main {
public static void main(String[] args) {
ServiceRunner<EmailService> runner = new ServiceRunner<>(EmailService::new);
runner.start(5);
}
}
Neste exemplo, EmailService::new é passado para ServiceRunner, que espera um ServiceFactory<EmailService>. O ServiceFactory então usa EmailService::new para criar novas instâncias de EmailService.
Espero ter ajudado. Qualquer dúvida manda aqui. Bons estudos.
