Please enable JavaScript.

Coggle requires JavaScript to display documents.

Patrón de Diseño - Coggle Diagram

- - - - Función de “guardar partida” o “deshacer cambios” en una aplicación o videojuego.
    - - Permite restaurar estados anteriores de forma segura.
      - Respeta el encapsulamiento del objeto.
    - - Usa tres participantes: Originator, Memento, Caretaker.
      - Guarda “instantáneas” del estado.
    - - Cuando necesitas recuperar versiones anteriores del estado de un objeto (historial, deshacer, checkpoints).
    - - Capturar y externalizar el estado interno de un objeto para poder restaurarlo más tarde, sin violar el encapsulamiento.
  - - - Sistema de notificaciones donde múltiples pantallas o usuarios reciben actualizaciones de un mismo dato.
    - - Bajo acoplamiento entre sujeto y observadores.
      - Actualización automática y consistente.
    - - Implementa suscripción (attach) y notificación (notify).
      - Observadores reaccionan a cambios del sujeto.
    - - Cuando varios objetos dependen del estado de otro y deben reaccionar en cuanto ese estado cambia.
    - - Definir una dependencia uno-a-muchos entre objetos de manera que, cuando uno cambie de estado, todos sus dependientes sean notificados automáticamente.
  - - - Ventana de diálogo con varios controles (botones, campos de texto) coordinados por un mediador.
    - - Hace el sistema más fácil de mantener y extender.
      - Reduce la complejidad de la comunicación entre objetos.
    - - Centraliza la comunicación entre componentes.
      - Los objetos no se referencian directamente entre sí.
    - - Definir un objeto que encapsula la forma en que interactúan varios objetos, promoviendo un acoplamiento débil.
    - - Cuando muchos objetos se comunican entre sí y la red de dependencias se vuelve difícil de manejar.
  - - - Máquina expendedora con estados: sin crédito, con crédito, dispensando producto, fuera de servicio.
    - - Código más limpio y organizado por estados.
      - Es fácil agregar nuevos estados o modificar los existentes.
    - - Cada estado se modela como una clase concreta.
      - El contexto delega el comportamiento en el estado actual.
    - - Cuando el comportamiento de un objeto depende fuertemente de su estado interno y tiene múltiples estados bien definidos.
    - - Permitir que un objeto altere su comportamiento cuando su estado interno cambia, pareciendo que cambia de clase.
  - - - Recorrer una lista, árbol o conjunto sin que el cliente tenga que saber cómo está implementado.
    - - Simplifica el recorrido de estructuras complejas.
      - Desacopla la colección de la lógica de recorrido.
    - - Define métodos estándar (siguiente, hayMás, actual).
      - Funciona con distintos tipos de colecciones.
    - - Cuando quieres ofrecer una forma uniforme de recorrer colecciones, sin mostrar su implementación interna.
    - - Proporcionar una forma de acceder secuencialmente a los elementos de una colección.
  - - - Acciones de un editor (copiar, pegar, deshacer) representadas como comandos con posibilidad de revertirse.
    - - Desacopla el emisor de la acción del receptor que la ejecuta.
      - Soporta fácilmente deshacer, rehacer y macros.
    - - Representa acciones como objetos independientes.
      - Puede almacenar historial de comandos.
    - - Cuando necesitas registrar operaciones, deshacerlas o ejecutar acciones en diferido.
    - - Encapsular una petición como un objeto, permitiendo parametrizar clientes, deshacer y registrar operaciones.
  - - - Elegir entre distintos algoritmos de ordenamiento (burbuja, quicksort, mergesort) según el contexto.
    - - Elimina condicionales múltiples para elegir algoritmos.
      - Facilita añadir nuevas estrategias sin modificar el código cliente.
    - - Cada algoritmo se implementa en una clase diferente.
      - El contexto mantiene una referencia a la estrategia en uso.
    - - Cuando tienes varias formas de realizar una tarea y quieres poder cambiarlas sin afectar al cliente.
    - - Definir una familia de algoritmos, encapsular cada uno y hacerlos intercambiables.
  - - - Sistema de soporte donde el ticket pasa por nivel 1, luego nivel 2, luego nivel 3 hasta que alguien lo resuelve.
    - - Elimina grandes estructuras if/else o switch.
      - Permite agregar o quitar manejadores sin afectar al cliente.
    - - Cada manejador decide si procesa o pasa la petición.
      - El orden de la cadena puede configurarse.
    - - Cuando varias capas u objetos pueden responder a una misma petición y no quieres acoplar la solicitud a un receptor específico.
    - - Evitar acoplar el emisor de una petición a su receptor, permitiendo que varios objetos la procesen en cadena.
  - - - Calcular impuestos, reportes o métricas sobre distintos tipos de elementos en una jerarquía (productos, servicios, paquetes).
    - - Puedes añadir nuevas operaciones sin modificar las clases base de la estructura.
      - Organiza la lógica compleja en clases Visitor.
    - - Separa las operaciones de la estructura de datos.
      - Usa doble despacho (element.accept(visitor)).
    - - Cuando tienes una estructura estable de clases y quieres agregar muchas operaciones diferentes sobre ella.
    - - Representar una operación que se realiza sobre los elementos de una estructura de objetos, permitiendo definir nuevas operaciones
  - - - Proceso de validación o procesamiento de archivos donde la secuencia es fija, pero algunos pasos cambian.
    - - Reutiliza la estructura común del algoritmo.
      - Facilita variaciones controladas del proceso.
    - - Clase base implementa la estructura general.
      - Subclases redefinen pasos específicos.
    - - Cuando varios algoritmos comparten la misma estructura, pero difieren en algunos pasos concretos.
    - - Definir el esqueleto de un algoritmo en una operación, dejando que las subclases definan algunos pasos.
- - - - Agregar cifrado y luego compresión a un flujo de datos sin cambiar la clase de flujo base.
    - - Gran flexibilidad para combinar comportamientos.
      - Evita crear muchas subclases con combinaciones fijas.
    - - Envuelve al objeto original en un “decorador”.
      - Permite encadenar varios decoradores.
    - - Cuando quieres agregar o quitar funcionalidades en tiempo de ejecución sin modificar clases existentes.
    - - Añadir responsabilidades adicionales a un objeto de forma dinámica sin cambiar su clase.
  - - - Clase “SistemaBancario” que agrupa operaciones de cuentas, préstamos y tarjetas en métodos sencillos.
    - - Disminuye la complejidad visible para el usuario.
      - Hace el sistema más fácil de usar y entender. :
    - - Simplifica las llamadas del cliente.
      - Cubre varios subsistemas detrás de una sola clase.
    - - Cuando un sistema tiene demasiadas clases o interfaces complejas y quieres ofrecer una entrada sencilla.
    - - Proporcionar una interfaz unificada y simple a un conjunto de interfaces en un subsistema complejo.
  - - - Sistema de archivos con carpetas que contienen archivos y otras carpetas.
    - - Simplifica el código cliente, que trata todo por igual.
      - Facilita agregar nuevos tipos de nodos.
    - - Organiza objetos en jerarquías (nodo hoja y nodo compuesto).
      - Todos implementan la misma interfaz.
    - - Cuando necesitas representar estructuras jerárquicas (parte-todo) y tratar elementos simples y compuestos de la misma forma.
    - - Componer objetos en estructuras de árbol para tratar elementos individuales y compuestos de forma uniforme.
  - - - Representar caracteres en un editor de texto donde cada letra no crea un objeto nuevo si ya existe.
    - - Ahorro considerable de memoria.
      - Mejora de rendimiento en colecciones muy grandes.
    - - Divide estado en intrínseco (compartido) y extrínseco (no compartido).
      - Usa una fábrica que gestiona instancias compartidas.
    - - Cuando tienes miles o millones de objetos similares que pueden compartir parte de su estado.
    - - Compartir objetos para soportar eficientemente grandes cantidades de objetos de grano fino.
  - - - Figuras geométricas (círculo, cuadrado) que pueden dibujarse con diferentes APIs gráficas (OpenGL, DirectX).
    - - Mayor flexibilidad para extender abstracciones o implementaciones.
      - Menos clases combinadas y más organización.
    - - Define dos jerarquías: abstracciones e implementaciones.
      - Evita una explosión de subclases combinadas.
    - - Cuando tienes dos dimensiones de cambio (por ejemplo: tipo de objeto y plataforma donde se usa).
    - - Separar una abstracción de su implementación para que ambas puedan variar independientemente.
  - - - Cargar una imagen pesada solo cuando realmente se muestra en pantalla (proxy virtual).
    - - Optimiza el rendimiento y el consumo de recursos.
      - Permite añadir controles sin cambiar el objeto real.
    - - Mantiene la misma interfaz que el objeto real.
      - Puede retrasar la creación o carga de recursos pesados.
    - - Cuando necesitas controlar el acceso a un objeto (por seguridad, rendimiento, carga diferida o acceso remoto).
    - - Proveer un sustituto o marcador de posición para controlar el acceso a otro objeto.
  - - - Conectar una librería antigua con una nueva API que espera métodos diferentes.
    - - Facilita la integración de sistemas heterogéneos.
      - Reutiliza código existente sin reescribirlo.
    - - Traduce llamadas de una interfaz a otra.
      - No requiere modificar el código original.
    - - Cuando quieres usar una clase existente cuya interfaz no coincide con la que necesita tu código.
    - - Permitir que dos clases con interfaces incompatibles trabajen juntas mediante un adaptador.
- - - - Sistemas distribuidos, microservicios, plataformas con alto volumen de lectura como e-commerce o aplicaciones financieras.
    - - Mejora el rendimiento en sistemas complejos, facilita escalar las lecturas, reduce conflictos en concurrencia
    - - Utiliza un modelo especializado para comandos (escrituras) y otro diferente para consultas (lecturas).
    - - Cuando las operaciones de lectura y escritura tienen requisitos muy distintos o cuando el sistema requiere escalabilidad avanzada.
    - - Separar las operaciones de lectura y escritura en modelos distintos para optimizar rendimiento, escalabilidad y claridad.
  - - - Sistemas empresariales complejos como ERPs, logística, sistemas bancarios, seguros
    - - Produce modelos alineados con el negocio, reduce malentendidos, facilita la evolución y mejora
    - - Divide el sistema en contextos delimitados, utiliza entidades ricas en comportamiento, establece un lenguaje ubicuo compartido
    - - Cuando trabajas en proyectos grandes o con reglas de negocio complicadas que necesitan un modelado profundo y evolutivo.
    - - Modelar el software basándose profundamente en el dominio del negocio, priorizando el conocimiento de expertos y un lenguaje común.
  - - - Aplicaciones Java, .NET o Python donde se necesita una capa organizada para interactuar con MySQL, SQL Server, Oracle
    - - Reduce el acoplamiento entre la lógica de negocio y la persistencia, facilita cambiar la base de datos y mejora la mantenibilidad del código.
    - - Define una capa que contiene métodos especializados para consultar, insertar, actualizar o eliminar datos.
    - - Cuando necesitas un acceso consistente y controlado a la base de datos y quieres evitar que todo el sistema manipule consultas directamente.
    - - Encapsular el acceso a la base de datos en un componente dedicado para aislar la lógica de negocio de los detalles de persistencia.
  - - - Aplicaciones con interfaces reactivas como WPF, Xamarin, MAUI, Angular o frameworks donde el databinding es esencial.
    - - Reduce código repetitivo, facilita pruebas unitarias, mejora la separación entre UI y lógica
    - - La vista muestra la interfaz, el modelo contiene los datos y el ViewModel expone la información en un formato adecuado
    - - Cuando se requiere una interfaz con fuerte enlace de datos y actualizaciones en tiempo real sin mezclar lógica con la vista.
    - - Separar la interfaz de usuario de la lógica y el estado utilizando un ViewModel que hace de puente entre ambos.
  - - - Aplicaciones con interfaces basadas en eventos como Windows Forms, WebForms, Android clásico
    - - Código más testable, vistas más simples y separación clara entre presentación y comportamiento.
    - - La vista es pasiva y solo muestra información, el modelo gestiona los datos y el presentador contiene toda la lógica
    - - Cuando necesitas mayor control sobre la presentación y debes probar la lógica de interfaz sin depender de la UI real.
    - - Separar la lógica de presentación de la vista y delegar toda la interacción en un presentador que actúa como intermediario.
  - - - Aplicaciones web como ASP.NET MVC, Spring MVC o Ruby on Rails donde la interfaz, la lógica y el control
    - - Mejora la organización del código, permite modificar la interfaz sin tocar la lógica y facilita trabajar en equipo al separar responsabilidades.
    - - El modelo gestiona los datos y la lógica del sistema, la vista representa la información al usuario y el controlador coordina la comunicación entre ambos.
    - - Cuando desarrollas aplicaciones con interfaz de usuario que requieren una estructura clara y separación de responsabilidades.
    - - Separar la lógica de negocio, la interfaz de usuario y el control del flujo en tres componentes independientes.
- - - - Una aplicación que debe crear distintos tipos de botones (Windows, Mac, Linux) según el sistema operativo.
    - - Reduce el acoplamiento entre el código y las clases concretas.
      - Facilita la extensión con nuevos productos.
    - - Se basa en herencia (clase base + subclases concretas).
      - Centraliza la lógica de creación de objetos.
      - Permite agregar nuevos tipos sin modificar el código cliente.
    - - Cuando el tipo exacto de objeto a crear se conoce solo en tiempo de ejecución o depende de una condición.
    - - Definir un método para crear objetos, delegando en las subclases qué tipo concreto instanciar.
  - - - Biblioteca de interfaz gráfica que genera ventanas, botones y menús con el mismo estilo (tema oscuro, claro, empresarial).
    - - Mantiene consistencia visual y funcional entre componentes.
      - Permite cambiar toda una familia de productos de forma sencilla.
    - - Crea “familias” completas de productos coherentes entre sí.
      - Oculta las clases concretas al cliente.
      - Garantiza compatibilidad entre los objetos producidos.
    - - Cuando necesitas que varios objetos trabajen juntos con un mismo “tema” o estilo y puedas cambiar toda la familia de una vez.
    - - Proveer una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
  - - - Construir un objeto “Auto” configurando motor, color, interiores, extras, etc.
    - - Código de construcción más legible y mantenible.
      - Soporte para múltiples configuraciones de un mismo producto.
    - - Organiza la creación en pasos (métodos encadenados).
      - Evita constructores con demasiados parámetros.
      - Permite crear diferentes versiones del mismo objeto.
    - - Cuando un objeto tiene muchas opciones, partes opcionales o configuraciones distintas.
    - - Separar la construcción de un objeto complejo de su representación para poder construirlo paso a paso.
  - - - Duplicar personajes en un videojuego con la misma configuración inicial (estadísticas, equipo, apariencia).
    - - Reduce el costo de creación de objetos complejos.
      - Permite reutilizar configuraciones estándar.
    - - Usa clonación (copia superficial o profunda).
      - Permite crear objetos a partir de “modelos base”.
      - Útil cuando la inicialización es costosa.
    - - Cuando crear un objeto desde cero es costoso y ya tienes una instancia configurada que puedes copiar.
    - - Crear nuevos objetos copiando (clonando) instancias existentes llamadas prototipos.
  - - - Gestor de configuración de la aplicación, logger central o gestor de conexión a base de datos.
    - - Evita instancias duplicadas que puedan causar inconsistencias.
      - Facilita el acceso a un recurso global.
    - - Método estático que devuelve siempre la misma instancia.
      - Constructor privado para evitar múltiples instancias.
    - - Cuando solo debe existir un objeto de ese tipo en toda la aplicación (config, logger, etc.).
    - - Garantizar que una clase tenga solo una instancia y proporcionar un punto de acceso global a ella.