design-patterns - diseño - patrones estructurales

¿Diferencia entre el patrón de diseño estructural y el patrón de diseño de comportamiento?

Question

Estaba leyendo los conceptos básicos de los patrones de diseño y encontré las dos definiciones básicas de patrones estructurales y patrones de comportamiento, que son como:

Patrones de diseño estructural: generalmente tratan las relaciones entre entidades, lo que facilita el trabajo conjunto de estas entidades.

Patrones de diseño de comportamiento: se utilizan en las comunicaciones entre entidades y facilitan y hacen más flexible la comunicación de estas entidades.

Al leerlo, no puedo diferenciar entre ellos, ¿puede alguien guiarme en cómo son diferentes, dando un ejemplo simple?

Answer 1

No estoy seguro de si mi explicación y ejemplo cubren los principios más importantes.

Piense en el comportamiento como escenarios externos a las estructuras. Una cierta estructura de datos se puede "utilizar" en múltiples comportamientos / escenarios.

Por otro lado, piense en la lógica relacionada con la estructura como algo interno de la estructura. La estructura se ve afectada por varios cambios y ejecuta algunas acciones como consecuencia.

Dicho esto podemos ejemplificar con lo siguiente:

Los patrones de diseño de la estructura definirán un weblog definiendo sus constituyentes como objetos de negocios de nivel superior, como Artículo / Imagen / Comentario. Los constituyentes están conscientes unos de otros y cómo conectarse entre sí.

$image = new Image;
$image->title = ''Image title'';
$image->url = ''http://example.com/file.ext'';
$image->save(); // will save the image to a DB

$article->title = ''The title i have set'';
/* $article->url_key = ''the_title_i_have_set''; */
// this ^^ element of logic will be done automatically by the article
$article->addImage($image); // will save the connection between the
                            // article and the image to DB

Los patrones de diseño de comportamiento definirán un weblog por sus casos de uso (escenarios) utilizando objetos de negocios de nivel inferior como Article / ArticleToImage / Image / ArticleToComment. Los objetos de negocio no son conscientes unos de otros y son "maniobrados" en su lugar por la lógica del escenario.

$image = new Image;
$image->title = ''Image title'';
$image->url = ''http://example.com/file.ext'';
$image->save(); // will save the image to a DB

$article->title = ''The title i have set'';
$article->url_key = $controller->getURlKey($article->title);
$article->save(); // saves article to DB

$article_to_image = new ArticleToImage;
$article_to_image->article = $article;
$article_to_image->image = $image;
$article_to_image->save();

TL; DR

Si los objetos de almacenamiento son inteligentes (contienen lógica) eso es diseño estructural. Si los objetos de almacenamiento son tontos (solo pueden almacenar datos y transferirlos a la base de datos), entonces necesita un diseño de comportamiento para administrarlos.

Answer 2

La mejor manera de explicar sería tomar dos ejemplos de dos categorías.

Compuesto de patrones estructurales define una estructura similar a un árbol, por lo que se enfoca en la relación. Uno a muchos y tiene un tipo de relaciones para que todo y parte puedan tratarse por igual.

El patrón del observador, por otro lado, de los patrones de diseño de comportamiento se centran en la comunicación. ¿Cómo le informamos a las partes interesadas cualquier cambio en el objeto? Tipo de editor a suscriptor. No define una estructura estricta, pero obliga a implementar métodos, es decir, canales de comunicación.

Espero que sea útil.

Answer 3

Lamento que mi explicación esté en C #.

El observador es un patrón de comportamiento: presenta una interfaz, lo que permite que un objeto se comunique sin ningún conocimiento concreto sobre el otro. También conocido como patrón de publicación-suscripción. Objeto para informar a otro objeto sobre su estado, sin el conocimiento de cuáles son estos objetos .

El adaptador es un patrón estructural: el adaptador convierte la interfaz de la clase dada en otra clase solicitada por el cliente. Envuelve una clase existente con una nueva interfaz. La impedancia hace coincidir un componente antiguo con un nuevo sistema. Permite que las clases trabajen juntas cuando esto es imposible debido a interfaces incompatibles.

Ejemplo de adaptador:

interface ITarget
{
  List<string> GetProducts();
}


public class VendorAdaptee
{
   public List<string> GetListOfProducts()
   {
      List<string> products = new List<string>();
      products.Add("Gaming Consoles");
      products.Add("Television");
      products.Add("Books");
      products.Add("Musical Instruments");
      return products;
   }
}


class VendorAdapter:ITarget
{
   public List<string> GetProducts()
   {
      VendorAdaptee adaptee = new VendorAdaptee();
      return adaptee.GetListOfProducts();
   }
}


class ShoppingPortalClient
{
   static void Main(string[] args)
   {
      ITarget adapter = new  VendorAdapter();
      foreach (string product in adapter.GetProducts())
      {
        Console.WriteLine(product);
      }
      Console.ReadLine();
   }
}

Ejemplo de observador: controlador de eventos y eventos justos

using System;
namespace wildert
{
    public class Metronome
    {
        public event TickHandler Tick;
        public EventArgs e = null;
        public delegate void TickHandler(Metronome m, EventArgs e);
        public void Start()
        {
            while (true)
            {
                System.Threading.Thread.Sleep(3000);
                if (Tick != null)
                {
                    Tick(this, e);
                }
            }
        }
    }
        public class Listener
        {
            public void Subscribe(Metronome m)
            {
                m.Tick += new Metronome.TickHandler(HeardIt);
            }
            private void HeardIt(Metronome m, EventArgs e)
            {
                System.Console.WriteLine("HEARD IT");
            }

        }
    class Test
    {
        static void Main()
        {
            Metronome m = new Metronome();
            Listener l = new Listener();
            l.Subscribe(m);
            m.Start();
        }
    }
}

Answer 4

Los patrones estructurales se utilizan para definir las propiedades estáticas del sistema (ver Diagrama de clase ).

Ejemplo : El patrón de fábrica se puede usar para crear entidades que constituyen su sistema. Puede tener un Button objeto que tiene diferentes propiedades gráficas en Windows frente a OS X. El patrón de fábrica creará el Button independientemente del sistema operativo y el objeto creado tendrá las mismas interfaces en ambos sistemas operativos , a pesar de tener diferentes elementos internos.

Los patrones de comportamiento se utilizan para definir el comportamiento dinámico del sistema (consulte los diagramas de Activity , Sequence , etc.).

Ejemplo : el patrón de adaptador se puede usar en el tiempo de ejecución para permitir de manera transparente la interfaz de 2 entidades que no comparten la interfaz entre ellas. Cambia efectivamente el comportamiento de un objeto en tiempo de ejecución.