Wat zijn onderbouwers in Java?

Een underbuilder is een klasse die een standaardimplementatie biedt van een builder voor een specifiek type. Met andere woorden, het is een builder die instances van een specifiek type bouwt. Stel dat u bijvoorbeeld een klasse heeft met de naam 'Car' en u wilt daarvoor een builder leveren. Je zou een onderbouwer als volgt kunnen definiëren:
```
class CarBuilder: Builder {
// Definieer de standaardwaarden voor de eigenschappen van Car
private var color: String = "red"
private var make: String = "toyota "
private var model: String = "corolla"
private var jaar: Int = 2015

// Definieer de builder-methoden die kunnen worden aangeroepen om de eigenschappen in te stellen
fun withColor(color: String): CarBuilder {
this.color = color
return this
}

leuk metMake(merk: String): CarBuilder {
this.make = make
retourneer dit
}

leuk withModel(model: String): CarBuilder {
this.model = model
retourneer dit
}

leuk metJaar(jaar: Int) : CarBuilder {
this.year = year
return this
}

// Definieer de methode om de Car-instantie te bouwen
override fun build(): Car {
return Car(color, make, model, year)
}
}
`` `
In dit voorbeeld is de klasse `CarBuilder` een onderbouwer voor de klasse `Car`. Het biedt een standaardimplementatie van de builder die kan worden gebruikt om exemplaren van `Car` te maken. Met de methoden `withColor`, `withMake`, `withModel` en `withYear` kunt u de eigenschappen van de `Car`-instantie instellen, en de `build`-methode wordt gebruikt om de `Car`-instantie daadwerkelijk te maken.

Underbuilders zijn handig wanneer u een standaardimplementatie van een builder voor een specifiek type wilt bieden, maar u ook wilt toestaan dat andere builders die implementatie uitbreiden of wijzigen. U kunt bijvoorbeeld een basisbouwer hebben die een standaardimplementatie van de eigenschappen biedt, en andere bouwers kunnen die basisbouwer vervolgens uitbreiden om extra eigenschappen toe te voegen of de bestaande te wijzigen.