Ce sunt Underbuilders în Java?

Un underbuilder este o clasă care oferă o implementare implicită a unui constructor pentru un anumit tip. Cu alte cuvinte, este un generator care construiește instanțe de un anumit tip.

De exemplu, să presupunem că aveți o clasă numită „Mașină” și doriți să furnizați un constructor pentru aceasta. Puteți defini un underbuilder astfel:
```
class CarBuilder : Builder {
// Definiți valorile implicite pentru proprietățile Car
private var color: String = "red"
private var make: String = "toyota „
private var model: String = „corolla”
private var year: Int = 2015

// Definiți metodele de constructor care pot fi apelate pentru a seta proprietăți
fun withColor(culoare: String): CarBuilder {
this.color = color
return this
}

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

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

fun withYear(an: Int) : CarBuilder {
this.year = year
return this
}

// Definiți metoda de construire a mașinii instance
override fun build(): Car {
return Car(culoare, marca, model, an)
}
}
`` `
În acest exemplu, clasa `CarBuilder` este un underbuilder pentru clasa `Car`. Acesta oferă o implementare implicită a constructorului care poate fi folosită pentru a crea instanțe de „Mașină”. Metodele `withColor`, `withMake`, `withModel` și `withYear` vă permit să setați proprietățile instanței `Car`, iar metoda `build` este folosită pentru a crea de fapt instanța `Car`.

Underbuilderii sunt util atunci când doriți să furnizați o implementare implicită a unui generator pentru un anumit tip, dar doriți, de asemenea, să permiteți altor generatori să extindă sau să modifice implementarea respectivă. De exemplu, este posibil să aveți un generator de bază care oferă o implementare implicită a proprietăților, iar apoi alți constructori pot extinde acel generator de bază pentru a adăuga proprietăți suplimentare sau pentru a le modifica pe cele existente.