Definição
O padrão Builder pode ser usado para facilitar a construção de um objeto complexo a partir de objetos simples. O padrão Builder separa também a construção de um objeto complexo da sua representação para que o mesmo processo de construção possa ser usado para criar uma outra composição de objetos. Os padrões relacionados incluem Abstract Factory e Composite.
Quando usar
• Quando o algoritmo para a criação de um objeto complexo deve ser independente das partes que compõem o objeto e como eles são montados.
• Quando o processo de construção deve permitir diferentes representações para o objeto que é construído.
• Quando você quer isolar os clientes a partir do conhecimento do real processo de criação e / ou produto resultante.
Benefícios
• O objeto construído está protegido contra os detalhes de sua construção.
• Código para a construção é isolada a partir do código de representação e ambos são de fácil substituição, sem afetar o outro.
• Permite o controle sobre o processo de construção.
• Dá-lhe a possibilidade de reutilização e / ou alterar o processo e / ou produto
de forma independente.
Desvantagens / consequências
Necessidade de flexibilidade na criação de vários objetos complexos. Necessidade de criar objetos objetos complexos, agregados.
Exemplo
Para construir uma casa, vamos tomar várias medidas:
1. Construir chão
2. Construir paredes
3. Construir telhado.
Para construir uma casa, vamos tomar várias medidas:
1. Construir chão
2. Construir paredes
3. Construir telhado.
Vamos usar uma classe abstrata housebuilder para definir estas três etapas. Qualquer subclasse de housebuilder seguirá estes três passos para construir a casa. Em seguida, usamos uma classe HouseDirector para forçar o fim das três etapas (que quer dizer que temos que construir paredes depois de terminado chão do edifício e antes do telhado do edifício). As ordens de HouseClient ocorre a construção de duas casas, uma casa de madeira e uma casa de alvenaria. Mesmo que as casas sejam de tipos diferentes (madeira e tijolo) elas são construídas da mesma forma. O processo de construção permite diferentes representações para o objeto que é construído.
public abstract class HouseBuilder {
protected House house;
protected Floor floor;
protected Walls walls;
protected Roof roof;
public abstract House createHouse();
public abstract Floor createFloor();
public abstract Walls createWalls();
public abstract Roof createRoof();
}
public class WoodBuilder extends HouseBuilder {
public Floor createFloor() {
floor = new WoodFloor();
return floor;
}
public House createHouse() {
house = new WoodHouse();
return house;
}
public Roof createRoof() {
roof = new WoodRoof();
return roof;
}
public Walls createWalls() {
walls = new WoodWalls();
return walls;
}
}
public class BrickBuilder extends HouseBuilder {
//similar to WoodBuilder
}
public class HouseDirector {
public House construcHouse(HouseBuilder builder) {
House house = builder.createHouse();
System.out.println(house.getRepresentation());
house.setFloor(builder.createFloor());
System.out.println(house.getFloor().getRepresentation());
house.setWalls(builder.createWalls());
System.out.println(house.getWalls().getRepresentation());
house.setRoof(builder.createRoof());
System.out.println(house.getRoof().getRepresentation());
return house;
}
}
public abstract class House {
protected Floor floor;
protected Walls walls;
protected Roof roof;
public Floor getFloor() {
return floor;
}
public void setFloor(Floor floor) {
this.floor = floor;
}
public Walls getWalls() {
return walls;
}
public void setWalls(Walls walls) {
this.walls = walls;
}
public Roof getRoof() {
return roof;
}
public void setRoof(Roof roof) {
this.roof = roof;
}
public abstract String getRepresentation();
}
public interface Floor {
public String getRepresentation();
}
public interface Walls {
public String getRepresentation();
}
public interface Roof {
public String getRepresentation();
}
public class WoodHouse extends House {
public String getRepresentation() {
return "Building a wood house";
}
}
public class WoodFloor implements Floor {
public String getRepresentation() {
return "Finished building wood floor";
}
}
public class WoodWalls implements Walls {
//similar to WoodFloor
}
public class WoodRoof implements Roof {
//similar to WoodFloor
}
// Similar structure for Brick family
public class BrickHouse extends House …
public class BrickFloor implements Floor …
public class BrickWalls implements Walls …
public class BrickRoof implements Roof …
public class HouseClient {
public static void main(String[] args) {
HouseDirector director = new HouseDirector();
HouseBuilder woodBuilder = new WoodBuilder();
BrickBuilder brickBuilder = new BrickBuilder();
// Build a wooden house
House woodHouse = director.construcHouse(woodBuilder);
System.out.println();
// Build a brick house
House brickHouse = director.construcHouse(brickBuilder);
}
}
Quando HouseClient é executado o resultado é:
Construir uma casa de madeira
Terminado o assoalho de madeira de construção
Acabamento paredes de madeira de construção
edifício com acabamento de madeira do telhado
Construir uma casa de tijolo
Acabamento piso de tijolos de construção
Acabamento das paredes de tijolo de construção
Terminado telhado tijolo de construção
Exemplo de uso
Construir uma casa de madeira
Terminado o assoalho de madeira de construção
Acabamento paredes de madeira de construção
edifício com acabamento de madeira do telhado
Construir uma casa de tijolo
Acabamento piso de tijolos de construção
Acabamento das paredes de tijolo de construção
Terminado telhado tijolo de construção
Exemplo de uso
Alguns exemplos de uso do padrão Builder em engenharia de conhecimento incluem geradores diferentes. Analisadores em vários compiladores também são projetados usando o Builder Pattern.
Nenhum comentário:
Postar um comentário