Metodo chamando Metodo

Programação
#1

Sou acostumado com a seguinte estrutura em Java.

objeto.metodo(string);

mas, deparei com a seguinte estrutura.

1) objeto.metodo().metodox();

ou

2) objeto.metodo().metodox().metodoy();

Como chama esse tipo de estrutura que vou encadeamos métodos como no exemplo 1 e 2?

1 curtida
#2

Dando uma pesquisada, parece que é um design pattern: Builder Pattern.

1 curtida
#3

Tem o Builder Pattern:

Classe:

package Classes;

public class Carro {
    
    private final int portas;
    private final String cor;

    public int getPortas() {
        return portas;
    }

    public String getCor() {
        return cor;
    }
    
    public Carro(int portas, String cor)
    {
        this.portas = portas;
        this.cor = cor;
    }
    
    public static class Builder
    {
        private int portas;
        private String cor;
        
        public Builder setPortas(int portas)
        {
            this.portas = portas;
            return this;
        }
        public Builder setCor(String cor)
        {
            this.cor = cor;
            return this;
        }
        
        public Carro getCar()
        {
            return new Carro(this.portas, this.cor);
        }
    }
}

Utilização:

Carro carro = new Carro
                .Builder()
                .setCor("Branco")
                .setPortas(4)
                .getCar();

E tem Interface Builder:

Classe:

package Classes;

import java.util.ArrayList;
import java.util.List;

public class Item {
    
    private List<String> items;
    private int Numero;

    public List<String> getItems() {
        return items;
    }

    public int getNumero() {
        return Numero;
    }
    
    public Item addItems(String nome)
    {
        if (items == null) 
            items = new ArrayList<>();
        items.add(nome);
        return this;
    }
    public Item setNumero(int numero)
    {
        this.Numero = numero;
        return this;
    }
}

Utilização:

Item item = new Item()
                .addItems("Item A")
                .addItems("Item B")
                .addItems("Item C")
                .setNumero(100);

São bem parecidos e a lógica de encadear métodos é o mesmo, o que difere é que usam nomenclaturas de código um pouco diferente. Recomendo utilizar a Interface Fluent, pelo fator simplicidade de código e desempenho.

1 curtida
#4

No livro effective java tem um item especifico sobre esse assunto onde ele orienta a utlizar Builder em vez de construtores quando o construtor necessitar de muitos parâmetros.

1 curtida