# Builder Pattern



## lowcast (22. Nov 2009)

Hi,

ich habe eine Klasse, deren Konstruktor viele Parameter hat. Aus diesem Grund habe ich mich für den Builder Pattern entschieden. Jedoch soll die Klasse veränderbar sein, d.h. es soll eine Möglichkeit geben einige Werte dieser Klasse zu verändern. Ist es richtig, wenn man wie folgt vorgeht mit dem setter in Klasse Raum.



```
public class Raum{

private int groesse;//Pflicht
private int volumen;//Pflicht
private String name;//Pflicht
//optionale
private int x=1;
private int y=1;
private int z=1;
...

public static class Builder{
private int groesse;//Pflicht
private int volumen;//Pflicht
private String name;//Pflicht
//optionale
private int x=1;
private int y=1;
private int z=1;
...

public Builder(int groesse, int volumen, Stirng name){
this....
}

public Builder xGroesse(int x){
x=x;
return this;}
.....
}

public Raum build(){
return new Raum(this);
}

}

private Raum(...){

}

public void setX(int x){
if(x==null) throw new UnitializedException();
x=x;
}
...
}
```


----------



## javimka (22. Nov 2009)

Vom Prinzip her schon, nur sollte dein setX so aussehen:

```
public void setX(int x) {
   this.x = x;
}
```
Die if-Abfrage x==null macht keinen Sinn, weil x niemals null sein kann. null ist nicht gleich 0 (als Zahl).
Und mit x=x speicherst du das x auch sich selbst ab, statt auf das x aus der Klasse, deswegen this.x = x;


----------



## lowcast (22. Nov 2009)

ok danke.


----------



## Wildcard (23. Nov 2009)

Ich finde es bei Buildern schöner wenn alle setter statt void sich selbst zurückliefern. Das ermöglicht schöne chains wie das:

```
Builder.myDefault().size(100,100).color(Color.WHITE).name("foobar").create();
```


----------



## Noctarius (23. Nov 2009)

Wildcard hat gesagt.:


> Ich finde es bei Buildern schöner wenn alle setter statt void sich selbst zurückliefern. Das ermöglicht schöne chains wie das:
> 
> ```
> Builder.myDefault().size(100,100).color(Color.WHITE).name("foobar").create();
> ```



full ack


----------



## lowcast (23. Nov 2009)

Hi,

ich habe hier zwei Klassen Vater und Sohn, wobei Vater abstrakt ist. 
Dieser Code ist unschön, wenn man ein Sohn Objekt erzeugt muss man in dem Beispiel zuerst das Alter initialisieren und anschließend den Namen. 


```
Vater vVater = new Sohn.SohnBuilder().alter(12).name("Heiko").build();
```

Gibt es vielleicht für dieses Beispiel eine bessere Möglichkeit? Es sollte natürlich berücksichtigt werden, dass Vater mehrere Parameter hat, andernfalls wäre ein BuilderPattern nicht notwendig.


```
public abstract class Vater {

	private String mName;

	public abstract static class BuilderVater {
		protected String mName;

		public BuilderVater name(String aName) {
			mName = aName;
			return this;
		}

		public abstract Vater build();
	}

	protected Vater(BuilderVater aBuilder) {
		mName = aBuilder.mName;
	}
}


public class Sohn extends Vater {

	private int mAlter;

	public static class SohnBuilder extends BuilderVater {
		private int mAlter;

		public SohnBuilder alter(int aAlter) {
			mAlter = aAlter;
			return this;
		}

		public Vater build() {
			return new Sohn(this);
		}

	}

	protected Sohn(SohnBuilder aBuilder) {
		super(aBuilder);
		mAlter = aBuilder.mAlter;
	}

}
```


----------



## bygones (24. Nov 2009)

Sohn ist eine Unterklasse von Vater ??

builder hin oder her - diese Verbindung find ich mehr als fragwuerdig...


----------

