Hoy vamos a echar un vistazo a otro patrón de fábrica abstracto que se usa con mucha frecuencia.Después de leer los principios, daremos los códigos fuente de implementación de .NET y JAVA.
definición:
Abstract Factory Pattern: proporciona una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases específicas.
Abstract Factory Pattern: proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
También conocido como modo Tool (Kit)
La fábrica de hormigón en el patrón de fábrica abstracto no solo crea un producto, es responsable de crear una familia de productos.
Cuando una jerarquía de fábrica puede crear todos los objetos en una familia de productos que pertenecen a diferentes jerarquías de productos , el patrón de fábrica abstracto es más simple y eficiente que el patrón de método de fábrica.
analizar:
Cada fábrica específica tiene solo uno o un conjunto de métodos de fábrica sobrecargados , y solo puede producir un producto , lo que puede generar una gran cantidad de clases de fábrica en el sistema, lo que inevitablemente aumentará la sobrecarga del sistema.
Una fábrica puede producir una serie de productos (una familia de productos) , lo que reduce en gran medida el número de clases de fábrica.
Estructura de jerarquía de productos: La estructura de jerarquía de productos es la estructura de herencia del producto.
Familia de productos: una familia de productos se refiere a un grupo de productos producidos por la misma fábrica y ubicados en diferentes estructuras de jerarquía de productos.
Diagrama de clase:
El patrón de fábrica abstracto contiene los siguientes 4 roles:
AbstractFactory (fábrica abstracta)
ConcreteFactory (fábrica de hormigón)
AbstractProduct (producto abstracto)
ConcreteProduct (producto específico)
aplicabilidad:
Un sistema no debe depender de los detalles de cómo se crean, componen y representan las instancias de clase de producto
Hay más de una familia de productos en el sistema, pero solo uno de ellos se usa a la vez
Los productos que pertenecen a la misma familia de productos se utilizarán juntos , esta restricción debe reflejarse en el diseño del sistema.
La estructura de nivel de producto es estable . Después de completar el diseño, no se agregará ninguna nueva estructura de nivel de producto al sistema o no se eliminará la estructura de nivel de producto existente.
ventaja:
Aísla la generación de clases concretas para que los clientes no necesiten saber qué se está creando
Cuando se diseñan varios objetos en una familia de productos para que funcionen juntos, se garantiza que los clientes siempre usen solo objetos de la misma familia de productos.
Es muy conveniente agregar una nueva familia de productos sin modificar el sistema existente, que se ajusta al principio de apertura y cierre.
defecto:
Es problemático agregar una nueva estructura de nivel de producto y requiere modificaciones importantes en el sistema original, e incluso en el código de la capa de abstracción, lo que obviamente traerá grandes inconvenientes y violará el principio de apertura y cierre.
@Agregar familia de productos
Para agregar una nueva familia de productos , el patrón de fábrica abstracta admite muy bien el principio de apertura y cierre . Solo necesita agregar un producto específico y una nueva fábrica específica correspondiente sin ninguna modificación al código existente .
@Agregar nueva estructura de nivel de producto
Para agregar una nueva estructura de jerarquía de productos , se deben modificar todos los roles de fábrica, incluidas las clases de fábrica abstractas. En todas las clases de fábrica, se deben agregar métodos para producir nuevos productos, lo que viola el principio de apertura y cierre.
Caso 1: (código .NET)
La lista de códigos incluye:
Programa.cs
using System;
using System.Configuration;
using System.Reflection;
namespace AbstractFactorySample
{
class Program
{
static void Main(string[] args)
{
//使用抽象层定义
SkinFactory factory;
Button bt;
TextField tf;
ComboBox cb;
//读取配置文件
string factoryType = ConfigurationManager.AppSettings["factory"];
//反射生成对象
factory = (SkinFactory)Assembly.Load("AbstractFactorySample").CreateInstance(factoryType);
bt = factory.CreateButton();
tf = factory.CreateTextField();
cb = factory.CreateComboBox();
bt.Display();
tf.Display();
cb.Display();
Console.Read();
}
}
}
Botón.cs
namespace AbstractFactorySample
{
interface Button
{
void Display();
}
}
SpringButton.cs
using System;
namespace AbstractFactorySample
{
class SpringButton : Button
{
public void Display()
{
Console.WriteLine("显示浅绿色按钮。");
}
}
}
BotónVerano.cs
using System;
namespace AbstractFactorySample
{
class SummerButton : Button
{
public void Display()
{
Console.WriteLine("显示浅蓝色按钮。");
}
}
}
TextField.cs
namespace AbstractFactorySample
{
interface TextField
{
void Display();
}
}SpringTextField.cs
using System;
namespace AbstractFactorySample
{
class SpringTextField : TextField
{
public void Display()
{
Console.WriteLine("显示绿色边框文本框。");
}
}
}
SummerTextField.cs
using System;
namespace AbstractFactorySample
{
class SummerTextField : TextField
{
public void Display()
{
Console.WriteLine("显示蓝色边框文本框。");
}
}
}
ComboBox.cs
namespace AbstractFactorySample
{
interface ComboBox
{
void Display();
}
}
SpringComboBox.cs
using System;
namespace AbstractFactorySample
{
class SpringComboBox : ComboBox
{
public void Display()
{
Console.WriteLine("显示绿色边框组合框。");
}
}
}
VeranoComboBox.cs
using System;
namespace AbstractFactorySample
{
class SummerComboBox : ComboBox
{
public void Display()
{
Console.WriteLine("显示蓝色边框组合框。");
}
}
}
SkinFactory.cs
namespace AbstractFactorySample
{
interface SkinFactory
{
Button CreateButton();
TextField CreateTextField();
ComboBox CreateComboBox();
}
}
SpringSkinFactory.cs
namespace AbstractFactorySample
{
class SpringSkinFactory : SkinFactory
{
public Button CreateButton()
{
return new SpringButton();
}
public TextField CreateTextField()
{
return new SpringTextField();
}
public ComboBox CreateComboBox()
{
return new SpringComboBox();
}
}
}
SummerSkinFactory.cs
namespace AbstractFactorySample
{
class SummerSkinFactory : SkinFactory
{
public Button CreateButton()
{
return new SummerButton();
}
public TextField CreateTextField()
{
return new SummerTextField();
}
public ComboBox CreateComboBox()
{
return new SummerComboBox();
}
}
}
Aplicación.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="factory" value="AbstractFactorySample.SpringSkinFactory"/>
</appSettings>
</configuration>Caso 2: (código JAVA)
ResumenFábrica
public interface IAnimalFactory {
ICat createCat();
IDog createDog();
}
ConcretoFábrica
public class BlackAnimalFactory implements IAnimalFactory {
public ICat createCat() {
return new BlackCat();
}
public IDog createDog() {
return new BlackDog();
}
}
public class WhiteAnimalFactory implements IAnimalFactory {
public ICat createCat() {
return new WhiteCat();
}
public IDog createDog() {
return new WhiteDog();
}
}
ResumenProducto
public interface ICat {
void eat();
}
public interface IDog {
void eat();
}
ConcretoProducto
public class BlackCat implements ICat {
public void eat() {
System.out.println("The black cat is eating!");
}
}
public class WhiteCat implements ICat {
public void eat() {
System.out.println("The white cat is eating!");
}
}
public class BlackDog implements IDog {
public void eat() {
System.out.println("The black dog is eating");
}
}
public class WhiteDog implements IDog {
public void eat() {
System.out.println("The white dog is eating!");
}
}
Prueba
public static void main(String[] args) {
IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
ICat blackCat = blackAnimalFactory.createCat();
blackCat.eat();
IDog blackDog = blackAnimalFactory.createDog();
blackDog.eat();
IAnimalFactory whiteAnimalF*ctory = new WhiteAnimalFactory();
ICat whiteCat = whiteAnimalFactory.createCat();
whiteCat.eat();
IDog whiteDog = whiteAnimalFactory.createDog();
whiteDog.eat();
}
El programa se ejecuta y devuelve el resultado:
¡El gato negro está comiendo! ¡El perro negro está comiendo! ¡El gato blanco está comiendo! ¡El perro blanco está comiendo!