Modo de constructor
La definición también se llama patrón del generador. Puede abstraer el proceso de construcción de objetos complejos (categorías abstractas), para que los diferentes métodos de implementación de este proceso abstracto puedan construir objetos con diferentes manifestaciones (atributos).
Cuando un algoritmo para crear un objeto complejo debe ser independiente de los componentes de ese objeto, y el proceso de construcción debe permitir que el objeto construido tenga diferentes representaciones. Podríamos considerar usar el modo Builder.
lograr
1. El constructor especifica una interfaz abstracta para cada componente que crea un objeto de producto. Por lo general, contiene métodos abstractos que crean y devuelven productos, o puede ser un método concreto, colocando el proceso de creación en la clase ConcreteBuilder.
2. ConcreteBuilder implementa la interfaz del constructor para construir y ensamblar varios componentes del producto.
3. El director es responsable de llamar al constructor apropiado para formar el producto. La clase del director generalmente no depende de la clase de producto. La clase Builder interactúa directamente con la clase Director.
4. El producto representa un objeto complejo a construir. ConcreateBuilder crea una representación interna del producto y define su proceso de ensamblaje.
/ ** "producto"*/ class Pizza {private String Dough = ""; salsa de cadena privada = ""; Topping de cadena privada = ""; public void setDough (masa de cadena) {this.dough = masa; } public void setSauce (salsa de cadena) {this.sauce = salsa; } public void setTopping (topping de cadena) {this.topping = topping; }} ''/** "Abstract Builder"*/'' Abstract Class PizzAbUilder {Pizza Pizza protegida; Public Pizza getpizza () {return pizza; } public void createenewpizzapRoducto () {pizza = new Pizza (); } public abstract void buildDough (); Public Abstract void BuildSauce (); público abstracto buildTopping (); } / ** "ConcreteBuilder"* / ClasswaiianPizzabuilder extiende Pizzabuilder {public void buildDough () {pizza.setDough ("cross"); } public void buildSauce () {pizza.setSauce ("leve"); } public void buildTopping () {pizza.settopping ("ham+piña"); }} / ** "ConcreteBuilder"* / Class SpicyPizzabuilder extiende Pizzabuilder {public void buildDough () {pizza.setDough ("Pan horneado"); } public void buildSauce () {pizza.setSauce ("caliente"); } public void buildTopping () {pizza.settopping ("Pepperoni+salami"); }} '' '/** "Director"*/' 'Classer de clase {Pizzabuilder privado Pizzabuilder; public void setPizzabuilder (Pizzabuilder PB) {pizzabuilder = pb; } public pizza getpizza () {return pizzabuilder.getpizza (); } public void constructpizza () {pizzabuilder.createenewpizzaproduct (); pizzabuilder.BuildDough (); pizzabuilder.BuildSauce (); pizzabuilder.BuildTopping (); }} /** Un cliente que pide una pizza. */ class BuilderExample {public static void main (string [] args) {Waiter Waiter = new Waiter (); Pizzabuilder hawaiian_pizzabuilder = new HawaiianPizzabuilder (); Pizzabuilder spicy_pizzabuilder = new SpicyPizzAbuilder (); camarero.setpizzabuilder (hawaiian_pizzabuilder); camarero.constructpizza (); Pizza pizza = camarero.getpizza (); }}El cliente crea el objeto Director y lo configura con el objeto Builder que desea. El director obtiene la solicitud del cliente para crear el producto y finalmente obtiene el producto.
ventaja
1. El proceso de construcción de objetos se puede controlar cuidadosamente para producir diferentes objetos de producto.
2. Fácil de expandir. Cuando hay un nuevo producto, puede agregar un nuevo ConcreteBuilder para lograrlo.
El patrón de fábrica abstracto de patrón relacionado es similar a los generadores porque también puede crear objetos complejos. La principal diferencia es que el patrón del generador se centra en construir un objeto complejo paso a paso. El modelo de fábrica abstracta se centra en múltiples series de objetos de productos (simples o complejos).
El generador devuelve el producto en el último paso, y para la fábrica abstracta, el producto regresa de inmediato.
Modo prototipo
Definir un patrón prototipo es un tipo de patrón de creación, que se caracteriza por "copiar" una instancia existente para devolver una nueva instancia, en lugar de crear una nueva instancia. El ejemplo copiado es lo que llamamos un "prototipo", que es personalizable.
El modo prototipo se usa principalmente para crear instancias complejas o que requieren mucho tiempo, porque en este caso, copiar una instancia existente hace que el programa se ejecute de manera más eficiente; o crear valores iguales, simplemente nombrando datos similares diferentes.
lograr
1. Cliente: cree un objeto nuevo y luego obtenga otro objeto a través del clon.
2. Prototipo: defina el método abstracto de un clon.
3. Concreteprototype - Implementar el método de clonos.
Prototipo de interfaz pública {Public Abstract Object Clone (); } public class ConcreteproTotype implementa prototipo {public object clone () {return super.clone (); }} Cliente de clase pública {public static void main (String arg []) {ConcreteproTotype obj1 = new ConcreteproTotype (); Concreteprototype obj2 = ConcreteproTotype) obj1.clone (); }} Ejemplo
1. Muchos elementos en el juego se repiten, y podemos usar el modo prototipo para copiar los mismos elementos.
2. Al hacer gráficos de datos, la primera vez que necesitamos leer datos de la base de datos y guardarlos en el objeto. Cuando necesitamos hacer otros gráficos de los mismos datos, usar el modo prototipo puede evitar volver a leer la base de datos.
Preguntas e implementaciones relacionadas
1. Si el número de prototipos que se creará no se soluciona, puede crear un administrador de prototipo. Antes de copiar el objeto prototipo, el cliente primero verifica si hay objetos prototipo que cumplen con las condiciones en el administrador de prototipos. Si lo hay, lo usará directamente. Si no, clone uno. Esto se llama forma de registro del modo prototipo.
2. Hay dos tipos de copia: copia profunda y copia superficial. Al copiar, el objeto de copia y el objeto prototipo comparten todas las variables internas del objeto, y los dos objetos tienen el mismo espacio de memoria y ciclo de vida. La modificación del objeto prototipo también modifica su réplica y viceversa.
En Java, siempre que implementa la interfaz clonable, puede llamar al método clon de la clase de objeto para lograr una copia superficial:
La clase pública ShallowClone implementa clonable {int Age; Persona persona; public void setAge (int a age) {this.age = edad; } public void setperson (nombre de cadena) {persona = nueva persona (nombre); } public object clone () lanza clonenotsupportedException {// El Java predeterminado implementa la copia Shallow de retorno super.clone (); }} persona de clase pública {nombre de cadena; Persona pública (nombre de cadena) {this.name = name; }} prueba de clase pública {public static void main (string [] args) lanza clonenotsupportedException {showoWclone OldShallowClone = new showoWClone (); OldshallowClone.setage (20); OldShallowClone.setPerson ("Eric"); System.out.println ("Oldname:" + OldshallowClone.person.name + "Age:" + OldshallowClone.age); ShallowClone NewshallowClone = (showoWClone) OldShallowClone.Clone (); System.out.println ("Newname:" + NewshallowClone.person.name + "Age:" + NewshallowClone.age); OldshallowClone.age = 30; OldShallowClone.person.name = "Frank"; System.out.println ("Newname:" + NewshallowClone.person.name + "Age:" + NewshallowClone.age); }} Producción:
Vigral: Eric Edad: 20NWNAME: Eric Age: 20NephName: Frank Age: 20
Se puede ver que la copia del objeto es una referencia al objeto. Cuando se cambia el valor del objeto, el objeto copiado también cambiará, y el tipo básico de Java es el valor copiado.
A continuación implementamos una copia profunda:
clase pública DeepClone {int Age; Persona persona; public void setAge (int a age) {this.age = edad; } public void setperson (nombre de cadena) {persona = nueva persona (nombre); } public DeepClone (DeepClone DeepClone) {this.age = DeepClone.age; this.person = nueva persona (DeepClone.person.name); } public DeepClone () {} public object clone () lanza ClonenotsupportedException {return New DeepClone (this); }} prueba de clase pública {public static void main (string [] args) lanza 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 + "edad:" + newdeepclone.age); OlddeepClone.age = 30; Olddeepclone.person.name = "Frank"; System.out.println ("Newname:" + newdeepclone.person.name + "edad:" + newdeepclone.age); }} Producción:
Vigral: Eric Edad: 20NWNAME: Eric Age: 20NephName: Eric Edad: 20
En el método de copia anterior, recreamos un objeto y recreamos la referencia para implementar una copia profunda.
ventaja
1. Copiar es mejor que la nueva.
2. Simplifique o oculte los detalles de la creación de objetos y copie directamente.