Modo construtor
A definição também é chamada de padrão gerador. Ele pode abstrair o processo de construção de objetos complexos (categorias abstratas), para que diferentes métodos de implementação desse processo abstrato possam construir objetos com diferentes manifestações (atributos).
Quando um algoritmo para criar um objeto complexo deve ser independente dos componentes desse objeto, e o processo de construção deve permitir que o objeto construído tenha representações diferentes. Podemos considerar o uso do modo Builder.
concluir
1. O construtor especifica uma interface abstrata para cada componente que cria um objeto de produto. Geralmente, ele contém métodos abstratos que criam e retornam produtos, ou pode ser um método concreto, colocando o processo de criação na classe concreta.
2. ConcreteBuilder implementa a interface do construtor para construir e montar vários componentes do produto.
3. O diretor é responsável por chamar o construtor apropriado para formar o produto. A classe do diretor geralmente não depende da classe de produto. A classe Builder interage diretamente com a classe do diretor.
4. O produto representa um objeto complexo a ser construído. O Builder do Concreate cria uma representação interna do produto e define seu processo de montagem.
/ ** "Produto"*/ classe Pizza {private String dough = ""; molho de corda privada = ""; Private String topping = ""; public void SetDough (massa de string) {this.dough = massa; } public void se setsauce (molho de cordas) {this.sauce = molho; } public void Setpopping (Topping de String) {this.topping = topping; }} ''/** "Builder Abstract"*/'' Classe abstrata pizzabuilder {pizza protegida; public pizza getpizza () {return pizza; } public void createnewpizzaproduct () {pizza = new pizza (); } abstrato público void BuildDough (); Public Abstract Void Buildsauce (); Public Resumo Void Buildtopping (); } / ** "concreteBuilder"* / classe havaianpizzabuilder estende Pizzabuilder {public void BuildDough () {Pizza.SetDough ("Cross"); } public void BuildSauce () {Pizza.SetSauce ("Mild"); } public void BuildTopping () {Pizza.Settopping ("Ham+Pineapple"); }} / ** "concretebuilder"* / classe spicypizzabuilder estende a pizzabuilder {public void BuildDough () {pizza.setdough ("pan assado"); } public void BuildSauce () {Pizza.SetSauce ("Hot"); } public void BuildTopping () {Pizza.Settopping ("Pepperoni+Salami"); }} ''/** "Diretor"*/'' Classe Waiter {private Pizzabuilder Pizzabuilder; public void setpizzabuilder (pizzabuilder pb) {pizzabuilder = pb; } public pizza getpizza () {return pizzabuilder.getpizza (); } public void constructpizza () {pizzabuilder.createnewpizzaproduct (); pizzabuilder.builddough (); pizzabuilder.buildsauce (); pizzabuilder.buildtopping (); }} /** Um cliente encomenda uma pizza. */ class BuildExample {public static void main (String [] args) {garçoneiro = new Waiter (); Pizzabuilder havaian_pizzabuilder = novo havaianpizzabuilder (); Pizzabuilder spicy_pizzabuilder = new spicypizzabuilder (); Waiter.Setpizzabuilder (Hawaiian_pizzabuilder); Waiter.Constructpizza (); Pizza pizza = waiter.getpizza (); }}O cliente cria o objeto do diretor e o configura com o objeto Builder que deseja. O diretor obtém a solicitação do cliente para criar o produto e finalmente obtém o produto.
vantagem
1. O processo de construção de objetos pode ser cuidadosamente controlado para produzir diferentes objetos de produto.
2. Fácil de expandir. Quando há um novo produto, você pode apenas adicionar um novo concreto para alcançá -lo.
O padrão de fábrica abstrato do padrão relacionado é semelhante aos geradores, pois também pode criar objetos complexos. A principal diferença é que o padrão do gerador se concentra na construção de um objeto complexo passo a passo. O modelo de fábrica abstrato se concentra em várias séries de objetos de produto (simples ou complexos).
O gerador retorna o produto na última etapa e, para a fábrica abstrata, o produto retorna imediatamente.
Modo de protótipo
Definir um padrão de protótipo é um tipo de padrão de criação, caracterizado por "copiar" uma instância existente para retornar uma nova instância, em vez de criar uma nova instância. O exemplo copiado é o que chamamos de "protótipo", que é personalizável.
O modo de protótipo é usado principalmente para criar instâncias complexas ou demoradas, porque neste caso, a cópia de uma instância existente faz com que o programa seja executado com mais eficiência; ou criando valores iguais, apenas nomeando dados semelhantes diferentes.
concluir
1. Cliente - Crie um novo objeto e, em seguida, obtenha outro objeto através do clone.
2 Protótipo - Defina o método abstrato de um clone.
3. ConcretePrototype - Implementar o método clone.
protótipo de interface pública {public abstract Object clone (); } classe pública concreteprototype implementa o protótipo {public object clone () {return super.clone (); }} public class Client {public static void main (string arg []) {concreteprototype obj1 = new concretePrototype (); Concreto prototipo obj2 = concretoprototipo) obj1.clone (); }} Exemplo
1. Muitos elementos do jogo são repetidos e podemos usar o modo de protótipo para copiar os mesmos elementos.
2. Ao fazer gráficos de dados, na primeira vez que precisamos ler os dados do banco de dados e salvá -los no objeto. Quando precisamos criar outros gráficos dos mesmos dados, o uso do modo de protótipo pode evitar relendo o banco de dados.
Perguntas e implementações relacionadas
1. Se o número de protótipos a serem criados não for corrigido, você poderá criar um gerenciador de protótipo. Antes de copiar o objeto de protótipo, o cliente primeiro verifica se existem objetos de protótipo que atendem às condições no gerenciador de protótipo. Se houver, ele o usará diretamente. Caso contrário, clone um. Isso é chamado de formulário de registro do modo de protótipo.
2. Existem dois tipos de cópia: cópia profunda e cópia rasa. Ao copiar, o objeto de cópia e o protótipo objeto compartilham todas as variáveis internas do objeto, e os dois objetos têm o mesmo espaço de memória e ciclo de vida. A modificação do protótipo objeto também modifica sua réplica e vice -versa.
Em Java, desde que você implemente a interface clonável, você pode chamar o método clone da classe de objeto para obter uma cópia superficial:
classe pública Shallowclone implementa clonável {int Age; Pessoa pessoa; public void Setage (int Age) {this.age = Age; } public void setPerson (nome da string) {Person = new Person (nome); } public Object clone () lança clonenotsupportedException {// O Java padrão implementa a cópia superficial Return Super.Clone (); }} public class Pessoa {Nome da String; Pessoa pública (nome da string) {this.name = name; }} public class Test {public static void main (string [] args) lança clonenotsupportEdException {shallowclone OldsHallowClone = new SHROULLCLONE (); OldsHallowClone.setage (20); OldsHallowClone.SetPerson ("Eric"); System.out.println ("OldName:" + OldshallowClone.person.name + "Age:" + OldsHallowClone.age); SHOULLOLLCLONE NEWSHOLLOWCLONE = (SHOULLCONE) OldsHallowClone.Clone (); System.out.println ("newName:" + NewsshallowClone.person.name + "Age:" + NewssHallowClone.age); OldsHallowClone.age = 30; OldshallowClone.person.name = "Frank"; System.out.println ("newName:" + NewsshallowClone.person.name + "Age:" + NewssHallowClone.age); }} Saída:
Oldname: Eric Idade: 20NewName: Eric Idade: 20NewName: Frank Idade: 20
Pode -se observar que a cópia do objeto é uma referência ao objeto. Quando o valor do objeto é alterado, o objeto copiado também muda e o tipo básico de Java é o valor copiado.
Abaixo, implementamos cópia profunda:
classe pública DeepClone {int Age; Pessoa pessoa; public void Setage (int Age) {this.age = Age; } public void setPerson (nome da string) {Person = new Person (nome); } public DeepClone (DeepClone DeepClone) {this.age = DeepClone.age; this.person = nova pessoa (DeepClone.person.name); } public DeepClone () {} public Object clone () lança clonenotsupportedException {return new DeepClone (this); }} public class Test {public static void main (string [] args) lança clonenotsupportEdException {DeepClone OlddeepClone = new DeepClone (); OlddeepClone.setage (20); OlddeepClone.setPerson ("Eric"); System.out.println ("OldName:" + OlddeepClone.person.name + "Age:" + OlddeepClone.age); DeepClone newDeepClone = (DeepClone) OlddeepClone.Clone (); System.out.println ("newName:" + newdeepClone.person.name + "Age:" + newdeepClone.age); OlddeepClone.age = 30; OlddeepClone.person.name = "Frank"; System.out.println ("newName:" + newdeepClone.person.name + "Age:" + newdeepClone.age); }} Saída:
Oldname: Eric Idade: 20NewName: Eric Idade: 20NewName: Eric Idade: 20
No método de cópia acima, recriamos um objeto e recriamos a referência para implementar cópias profundas.
vantagem
1. A cópia é melhor que a nova.
2. Simplifique ou oculte os detalhes da criação de objetos e copie -os diretamente.