Dándole nombre a un viejo amigo: Chaining

Wow! Siempre me había preguntado cómo es que se hacía algo así. Cuando hago APIs en Java, me encuentro muy seguido con esto:

Es interesante como el profesor explica cosas que usualmente un programador utiliza diariamente y no conoce el “como” y “por que” funciona.

Chaining o Encadenamiento

⠀
El Chaining o encadenamiento consiste en hacer llamadas consecutivas a diferentes metodos de un mismo objeto.
⠀
Un ejemplo claro es al utilizar la clase StringBuilder, esta permite encadenar llamadas al objeto creado inicialmente para manipular la creación de un String.

StringBuilder stringBuilder = new StringBuilder();
String s = stringBuilder.append("Hola") // Agrega el texto "Hola"
        .append(" world")               // Agrega el texto " world"
        .delete(5, 10)                  // Borra el texto "world" (por índices)
        .append("mundo")                // Agrega el texto "mundo"
        .reverse()                      // Invierte el texto
        .toString();                    // Lo convierte a String (termina la cadena)
System.out.println(s);                  // Imprime "odnum aloH"

La explicación detrás de este comportamiento es que cada una de las funciones aplica el cambio correspondiente y devuelve una referencia al mismo objeto (return this;), lo que hace posible llamar otra función sin perder el cambio realizado en la anterior.

estoy un poco confundido pense que esto se llamaba patron builder, en donde podia instanciar un elemento con los atributos de la clase que yo seleccionara.
Employee employee = new Builder().name(“John”).lastName(“Doe”).department(“Accounting”).build();

Es lo mismo o en algo difiere??

Chaining es un ecadenamiento de llamadas

Bueno, por lo menos yo no sabia esto. Gracias

hice un ejemplo pocho con hates ou yeaaa

package com.platzi.functional._10_chaining.data;

import com.platzi.functional._06_reference_operator.TestArea;

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

public class HotDogs {
    public static void main(String[] args) {
        Hate hSinTochino = new Hate();
        hSinTochino.agregarIngrediente("Sin tocino")
                .agregarIngrediente("Crema")
                .agregarIngrediente("Tomate")
                .agregarIngrediente("Catsu")
                .dondeComer("Para llevar")
                .cantidadDeHates(2);
        System.out.println(hSinTochino);
    }
    /*
    * Se crea una clase statica de un objeto, en la cual los métodos de ella returnean siempre el propio objeto
    * por lo cual se le pueden seguir aplicando los otros metodos, de esta manera, se puede, por ejemplo crear un hate
    * pasandole los ingredientes, podria haber otro metodo, indicando por ejemplo si es para llevar, cuantos pedirá y
    * se seguirian pudiendo usar siempre y cuando se devuelvan en todos los métodos el propio objeto, es como
    * andarse pasando una papa cacliente
    * */
    static class Hate{
        ArrayList<String> ingredientes = new ArrayList<>();
        int cantidadHates;
        String dondeComer;
        public Hate() {
            this.ingredientes.add("Salchicha");
            this.ingredientes.add("Pan");
        }

        public Hate agregarIngrediente(String ingrediente){
            ingredientes.add(ingrediente);
            return this;
        }
        public Hate dondeComer(String ubicacion){
            this.dondeComer = ubicacion;
            return this;
        }

        public Hate cantidadDeHates(int cantidad){
            this.cantidadHates = cantidad;
            return this;
        }

        @Override
        public String toString() {
            return
                    "Ingredientes:    "+ingredientes.toString() + "\n" +
                    "Cantidad:        " + cantidadHates + "\n"+
                    "Pa donde se fue: " + dondeComer;
        }
    }
}

Este profe explica bien y sin relleno irrelevante.

Este concepto se llama fluent interface

Chaining es el resultdo de una ejecucion con respecto a otra ejecucion

Chaining no ayuda a encadenar funciones sin necesidad de guardar los resultados en variables

Excelente clase instructor Sinuhé, no conocía esta forma de encadenar funciones, la aprovechare y la implementare cuando vea la oportunidad.

super! tampoco conocía este concepto 😃

Muy interesante, es algo que me volvió loco cuando empecé a aprender a programar con Java. Y al final es algo que aprendí con la práctica sin darme cuenta.
Ahora soy totalmente consciente gracias a esta explicación.

Muchas gracias, ahora entiendo la funcioinalidad de chaining.

El Chaining nos da la posibilidad de encadenar una seria de procedimientos sobre un objeto dado.