¿Qué son los Underbuilders en Java?

Un subconstructor es una clase que proporciona una implementación predeterminada de un constructor para un tipo específico. En otras palabras, es un constructor que crea instancias de un tipo específico. Por ejemplo, digamos que tiene una clase llamada "Car" y desea proporcionarle un constructor. Podrías definir un subconstructor como este:
```
class CarBuilder : Builder {
// Definir los valores predeterminados para las propiedades de Car
private var color: String = "red"
private var make: String = "toyota "
modelo de var privada: String = "corolla"
año de var privada: Int = 2015

// Definir los métodos de creación que se pueden llamar para establecer las propiedades
fun withColor(color: String): CarBuilder {
this.color = color
return this
}

fun withMake(make: String): CarBuilder {
this.make = make
return this
}

fun withModel(modelo: String): CarBuilder {
this.model = model
return this
}

fun withAño(año: Int) : CarBuilder {
this.year = año
return this
}

// Definir el método para construir la instancia de Car
override fun build(): Car {
return Car(color, marca, modelo, año)
}
}
`` `
En este ejemplo, la clase `CarBuilder` es un subconstructor de la clase `Car`. Proporciona una implementación predeterminada del constructor que se puede utilizar para crear instancias de "Car". Los métodos `withColor`, `withMake`, `withModel` y `withYear` le permiten establecer las propiedades de la instancia `Car`, y el método `build` se utiliza para crear realmente la instancia `Car`.

Los Underbuilders son útil cuando desea proporcionar una implementación predeterminada de un constructor para un tipo específico, pero también desea permitir que otros constructores extiendan o modifiquen esa implementación. Por ejemplo, es posible que tenga un constructor base que proporcione una implementación predeterminada de las propiedades y luego otros constructores puedan ampliar ese constructor base para agregar propiedades adicionales o modificar las existentes.