Ejemplo detallado de patrón de diseño de fábrica en programación de Android

Este artículo narra un ejemplo de patrón de diseño de fábrica en programación Android. Compartimos con ustedes para que lo refieran, como se muestra a continuación:

uno, introducción

El patrón de método de fábrica (Factory Pattern) es uno de los patrones de diseño de creación. El patrón de método de fábrica es un patrón estructural simple, que se aplica muy ampliamente en nuestro desarrollo cotidiano, tal vez no lo sepas, pero ya lo has utilizado miles de veces, como los métodos de ciclo de vida de Activity en Android, por ejemplo, onCreate, que se puede considerar como un método de fábrica, donde podemos construir nuestro View y devolverlo a framework para su procesamiento mediante setContentView, etc., contenido relacionado lo hablaremos más adelante, primero veamos la definición del patrón de método de fábrica.

dos, definición

definir una interfaz para crear objetos, dejando que las subclases decidan qué clase instanciar.

tres, escenarios de uso

En cualquier lugar donde se necesite generar objetos complejos, se puede utilizar el patrón de método de fábrica. Los objetos complejos son adecuados para usar el patrón de fábrica, y los objetos creados con new no necesitan usar el patrón de fábrica.

cuatro, implementación simple del patrón

clase de producto abstracta：

public abstract class Producto {
  /**
   * método abstracto de la clase de producto
   * por la clase de producto específica para implementar
   * */
  public abstract void método();
}

Clase de producto específico A:

public class ConcreteProductA extends Product {
  @Override
  public void method() {
    System.out.println("Soy el producto específico A");
  }
}

Clase de producto específico B:

public class ConcreteProductB extends Product {
  @Override
  public void method() {
    System.out.println("Soy el producto específico B");
  }
}

Clase de fábrica abstracta:

public abstract class Factory {
  /**
   * Método de fábrica abstracto
   * Implementado por la subclase
   * 
   * @return El objeto de producto específico
   * */
  public abstract Product createProduct();
}

Clase de fábrica específica:

public class ConcreteFactory extends Factory {
  /**
   * Clase de fábrica específica
   * */
  @Override
  public Product createProduct() {
    return new ConcreteProductA();
  }
}

Clase de cliente:

public class Client {
  public static void main(String[] args) {
    Factory factory = new ConcreteFactory();
    Product product = factory.createProduct();
    product.method();
  }
}

Resultados:

Soy el producto específico A

Estos roles son bastante simples, se dividen principalmente en cuatro módulos: primero es la fábrica abstracta, que es el núcleo del patrón de método de fábrica; segundo es la fábrica específica, que implementa la lógica de negocio específica; tercero es el producto abstracto, que es la clase padre de los productos creados por el patrón de método de fábrica; cuarto es el producto específico, que es el objeto que realiza el producto específico del producto abstracto.

En el código anterior, creamos una instancia de fábrica en la clase Client y producimos un objeto de producto a través de ella, el objeto de producto que obtenemos es una instancia de ConcreteProductA, si queremos obtener una instancia de ConcreteProductB, solo necesitamos cambiar la lógica en ConcreteFactory:

public class ConcreteFactory extends Factory {
  /**
   * Clase de fábrica específica
   * */
  @Override
  public Product createProduct() {
    //return new ConcreteProductA();
    return new ConcreteProductB();
  }
}

Este método es bastante común, produce el producto necesario cuando se necesita, a veces también se puede utilizar una manera más sencilla de reflexión para producir objetos de productos específicos, en este caso, se necesita pasar una clase Class en la lista de parámetros del método de fábrica para determinar qué clase de producto es:

public abstract class Factory {
  /**
   * Método de fábrica abstracto
   * Implementado por la subclase
   * 
   * @param clz Tipo de clase del objeto de producto
   * 
   * @return El objeto de producto específico
   * */
  public abstract <T extends Product> T createProduct(Class<T> clz);
}

Para las clases de fábrica específicas, se puede obtener una instancia de la clase mediante reflexión:

public class ConcreteFactory extends Factory {
  /**
   * Clase de fábrica específica
   * */
  @SuppressWarnings("unchecked")
  @Override
  public <T extends Product> T createProduct(Class<T> clz) {
    Product product = null;
    try {
      product = (Product) Class.forName(clz.getName()).newInstance();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return (T)product;
  }
}

Veamos la implementación en Client:

public class Client {
  public static void main(String[] args) {
    Factory factory = new ConcreteFactory();
    Product product = factory.createProduct(ConcreteProductB.class);
    product.method();
  }
}

Puedes pasar el tipo de la clase que necesitas y se puede obtener el objeto correspondiente, este método es más conciso y dinámico. Si no te gusta esta manera, también puedes intentar definir una fábrica específica para cada producto, cada una con sus propias responsabilidades.

public class ConcreteFactoryA extends Factory {
  /**
   * Clase de fábrica específica
   **/
  @Override
  public Product createProduct() {
    return new ConcreteProductA();
  }
}
public class ConcreteFactoryB extends Factory {
  /**
   * Clase de fábrica específica
   **/
  @Override
  public Product createProduct() {
    return new ConcreteProductB();
  }
}
public class Client {
  public static void main(String[] args) {
    Factory factoryA = new ConcreteFactoryA();
    Product productA = factoryA.createProduct();
    productA.method();
    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.createProduct();
    productB.method();
  }
}

De esta manera, tener múltiples fábricas se conoce como patrón de método de múltiples fábricas. Del mismo modo, volvamos al patrón de método de fábrica original, cuando solo tenemos una fábrica, aún proporcionamos una clase abstracta para la fábrica, ¿podemos simplificarla? Si estás seguro de que tu clase de fábrica solo tiene una instancia, simplificar la clase abstracta no presentará problemas, solo necesitas cambiar el método de fábrica correspondiente a un método estático:

public class Factory {
  /**
   * Clase de fábrica específica
   **/
  @Override
  public static Product createProduct() {
    return new ConcreteProductA();
  }
}

Este tipo de manera también se llama patrón de fábrica simple o patrón de fábrica estático, es una versión debilitada del patrón de fábrica de métodos.

En realidad, aquí todos deben poder descubrir que el patrón de fábrica de métodos cumple completamente con los principios de diseño, reduce la耦合 entre objetos, y el patrón de fábrica de métodos depende de la arquitectura abstracta, que delega la tarea de instanciación a las subclases, tiene muy buena capacidad de expansión.

Cinco, el patrón de fábrica de métodos en el código fuente de Android

Varios ciclos de vida de Activity

ArrayList y HashSet

Seis, resumen

Ventajas:

El patrón de fábrica de métodos cumple completamente con los principios de diseño, reduce la耦合 entre objetos. Los módulos de alto nivel solo necesitan conocer la clase abstracta del producto, y no necesitan preocuparse por otras implementaciones.

Buena encapsulación, estructura de código clara. Buena capacidad de expansión.

Desventajas:

Cada vez que añadimos un nuevo producto al patrón de fábrica de métodos, debemos escribir una nueva clase de producto. Además, también es necesario introducir una capa abstracta, lo que inevitablemente llevará a la complejidad de la estructura de clases, por lo que, en ciertas situaciones sencillas, si es necesario usar el patrón de fábrica, debe ser ponderado por el diseñador.

Los lectores interesados en más contenido relacionado con Android pueden consultar las secciones especiales de este sitio: 'Tutorial de introducción y avanzado de desarrollo de Android', 'Técnicas de depuración y resumen de métodos de solución de problemas comunes de Android', 'Resumen de uso de componentes básicos de Android', 'Resumen de técnicas de View de Android', 'Resumen de técnicas de layout de Android' y 'Resumen de uso de controles de Android'.

Espero que lo descrito en este artículo pueda ayudar a todos en el diseño de programas Android.

Declaración: El contenido de este artículo se obtiene de la red, es propiedad del autor original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha realizado un procesamiento editorial humano y no asume ninguna responsabilidad legal relacionada. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplace # con @) para denunciar, y proporcione evidencia relevante. Una vez confirmado, este sitio eliminará inmediatamente el contenido sospechoso de infracción.