Este artículo describe el modelo de fábrica del patrón de diseño Java. Compártelo para su referencia, como sigue:
1. Fábrica simple
Pensemos primero en una pregunta. Cuando escribamos programas, habrá tal situación. Objeto A necesita llamar al método de objeto B. En este momento, generalmente usamos la nueva palabra clave para crear una instancia B y luego llamar al método de instancia B. La desventaja de este enfoque es que el método de clase A llama directamente el nombre de clase de la clase B (este método también se llama acoplamiento codificado). Una vez que el sistema necesita ser refactorizado: cuando la clase C necesita usarse en lugar de la Clase B, el programa debe modificar el código de Clase A. Si 100 o 10,000 clases en la aplicación están codificadas, 100 o 10,000 lugares deben modificarse, lo que obviamente es algo muy terrible.
Mirando este problema desde otra perspectiva: para un objeto ya A, solo necesita llamar al método del objeto B, y no le importa el proceso de implementación y creación del objeto B, considere dejar que la clase B implementa una interfaz IB, mientras que la clase A solo necesita ser acoplada con la interfaz IB: la clase A no usa la nueva clave para crear Bestancias B, pero redefine la Factory de la Factorial: IB Factory, que es responsable de la IB, y la Casta de Clasifique directamente, y las instancias de la Factor de la fábrica de IB, que es responsable de la IB, y la Casta, y la Casta, y la Clasea, y las instancias de la Factor, la Factor de la Factoria, es responsable de IB, de IB, de la Factor, es responsable de IB, y que se responsabiliza, y se utiliza. Llamando a la fábrica IBFactory para obtener instancias IB. A través del diseño anterior: si necesita usar la Clase C en lugar de la Clase B, solo necesita dejar que la Clase C implemente la interfaz IB y reescribir el código de implementación para crear una instancia de IB en la fábrica IBFactory, para que la fábrica pueda generar una instancia C. Este método de diseño para entregar múltiples objetos de clase a clases de fábrica para la generación se llama patrón de fábrica simple.
Aquí está el código para el patrón de fábrica simple:
/*** Modo de fábrica simple* Interfaz común que requiere instancias de objetos producidas por fábrica* Interfaz de estilo de cabello* @author Administrator**/public Interface Hair {/*** Draw Hairstyle*/public void Draw ();}/*** Distribución lateral de la izquierda Distribución* @author Administrator**/public class Lefthair implementa el cabello {@Override Void Draw () @@author Administrator*** System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * */public class Rightair implementa el cabello {@Override public void Draw () { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- Administrador * */clase pública de peluquería {Public static void main (String [] args) {Hairfactory Factory = new Hairfactory ();Como puede ver, si desea cambiar el Lefthair generado en la pelota de peluquería a Righthair, solo necesita modificar la implementación del método Gethair en HairFactory.
La ventaja de usar el modo de fábrica simple es que separa la persona que llama y el proceso de creación de objetos. Cuando la persona que llama el objeto necesita un objeto, puede solicitarlo directamente de la fábrica, evitando así la persona que llama de objeto y la clase de implementación de objetos que se acoplan de manera codificada para mejorar la mantenibilidad y la escalabilidad del sistema. Por supuesto, el modelo de fábrica también tiene un pequeño defecto. Cuando el producto se modifica, la clase de fábrica también debe modificarse en consecuencia. Aquí puede usar el modelo de política para resolverlo. El siguiente es el código.
Interfaz pública HairBuilder { / *** Make Hairstyle* @return* / public Hair gethair ();} public class LefthairBuilder implementa HairBuilder {@Override public Hair gethair () {return New LefThair (); }} public class RighthairBuilder implementa HairBuilder {@Override public cabHair () {return new Rightair (); }} clase pública HairFactory {PRIVADO PEALBUILDER PEACUILD; Public HairFactory (HairBuilder HairBuilder) {this.hairBuilder = HairBuilder; } public void SethairBuilder (HairBuilder HairBuilder) {this.hairBuilder = HairBuilder; } Public Hair gethair () {return HairBuilder.gethair (); }} Public Class Hairtest {public static void main (string [] args) {// HairBuilder Builder = new LefthairBuilder (); HairBuilder Builder = New RighThairBuilder (); HairFactory Factory = New HairFactory (Builder); Cabello cabello = fábrica.gethair (); cabello.draw (); }}La ventaja de este enfoque es que ya no hay necesidad de modificar la clase de fábrica y abstraer la lógica de creación en la fábrica de acuerdo con diferentes estrategias. ¿Qué objetos deben crear el programa? Simplemente pase el constructor correspondiente a la fábrica de redes.
2. Método de fábrica
En el modelo de fábrica simple, el sistema utiliza la clase de fábrica para producir todas las instancias de productos, y la clase de fábrica decide qué clase de instancias producir, es decir, la clase de fábrica es responsable de todos los juicios lógicos, la creación de instancias y otros trabajos.
Si no desea hacer juicios lógicos en la clase de fábrica, el programa puede proporcionar diferentes fábricas para diferentes categorías de productos, y diferentes clases de fábrica producen diferentes productos, sin hacer juicios lógicos complejos en la clase de fábrica. Esto es un poco similar al modelo de fábrica simple combinado con el modelo de estrategia anterior. La diferencia es que el primero solo tiene una fábrica, mientras que la segunda requiere múltiples fábricas. A continuación se muestra el código para el patrón de método de fábrica.
/*** Patrón de método de fábrica* Interfaz común requerida para ser implementada por instancias de objetos producidas por la fábrica* @Author Administrator**/Public Interface Person {public void Drawperson ();} El hombre de clase pública implementa a la persona {@Override public void drawperson () { System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- @Author Administrator * */clase pública Implementa PersonaFactory {@Override Public Person Getperson () {return new Women (); Factory.getPerson ();La característica típica de este tipo es que produce sus productos correspondientes de acuerdo con diferentes fábricas en el código del cliente, y no es necesario poner toda la lógica compleja en la clase de fábrica para juzgar. Hay una falla obvia en esta implementación, que es que el cliente se combina con la clase de fábrica.
3. Fábrica abstracta
Utilizando la arquitectura de diseño anterior del método de fábrica, el código del cliente se separa correctamente de la clase de implementación del objeto llamado, pero trae otro acoplamiento: el código del cliente se combina con diferentes clases de fábrica. Para resolver este problema de acoplamiento, considere agregar una clase de fábrica para generar instancias de fábrica y separar la fábrica del cliente para producir productos. Este método de diseño se llama modelo de fábrica abstracta. A continuación se muestra el código para el patrón de fábrica abstracta
/*** Patrón de fábrica abstracto* Factory Producting PersonFactory* @author Administrator**/public class PersonFactoryFactory {public static Personfactory getPersonFactory (type de cadena) {if (type.equalSignorecase ("man")) {return new ManFactory (); } else {return new WomenFactory (); }}}/** * Clase de prueba del cliente * @Author Administrator * */public class PersonTest {public static void main (String [] args) {PersonFactory factory = PersonFactoryFactory.getPersonFactory ("Man"); Persona persona = factory.getperson (); persona.drawperson (); }}Para obtener más contenido relacionado con Java, los lectores interesados en este sitio pueden ver los temas: "Estructura de datos de Java y tutorial de algoritmo", "Resumen de las puntas de nodo de operación Java DOM", "Resumen de los archivos Java y consejos de operación de directorio" y "Summary of Java Cache Operation Tips" ".
Espero que este artículo sea útil para la programación Java de todos.