Difference between Structural Design Pattern and Behavioral Design Pattern? [closed]

Answer 1

Best way to explain would be to take two examples from two categories.

Composite from Structural patterns defines a tree like structure, so focuses on the relationship. One to many and has a type of relationships so that whole and part can be treated alike.

Observer pattern on the other hand from Behavioral design patterns focus on communication. How do we let the interested parties know any changes to the object. Sort of publisher to subscriber. Does not define a strict structure, but forces on implementing methods, i.e. channels of communications.

Hope it's useful.

Answer 2

Structural patterns are used for defining the static properties of the system (see Class diagram).

Example: Factory pattern can be used to create entities which constitute your system. You can have object Button that have different graphical properties on Windows vs. OS X. Factory pattern will create the Button regardless of the OS and the created object will have the same interfaces on both OSs expose the same behavior despite having different internals.

Behavioral patterns are used for defining the dynamic behavior of the system (see Activity, Sequence etc. diagrams).

Example: Adapter pattern can be used at runtime to transparently allow interfacing of 2 entities that do not share interface between them. It effectively changes the behavior of an object at runtime.

Answer 3

I am pretty unsure if my explanation and example really cover the most important principles

Think of behavior as scenarios external to the structures. A certain data structure can "be used" in multiple behaviors/scenarios.

On the other hand think of structure related logic as being internal to the structure. The structure gets affected by various changes and executes some actions as a consequence.

That being said we can exemplify with the following:

Structure design patterns will define a weblog by defining its constituents as higher level business objects such as Article/Image/Comment. The constituents are aware of one another and how to connect to each other.

$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

Behavior design patterns will define a weblog by its use cases (scenarios) using lower level business objects such as Article/ArticleToImage/Image/ArticleToComment. The business objects are not aware of each other and are "maneuvered" into place by the scenario logic.

$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

If the storage objects are smart (contain logic) that's structural design. If the storage objects are dumb (they can only store data and transfer it to the DB) you then need a behavioral design to manage them.

Answer 4

Sorry that my explanation will be in C#.

Observer is behavioral pattern: Presents interface, allowing object to communicate without any concrete knowledge about each other. Also known as Publish-Subscribe pattern. Object to inform other object about its state, without the knowledge which are these objects.

Adapter is structural pattern: Adapter converts the given class' interface into another class requested by the client. Wrap an existing class with a new interface. Impedance match an old component to a new system. Allows classes to work together when this is impossible due to incompatible interfaces.

Adapter example:

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();
   }
}

Observer example: Event handler and just events

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();
        }
    }
}