Կամուրջ (նախագծման ձևանմուշ)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Jump to navigation Jump to search
HS Disambig.svg Անվան այլ կիրառումների համար տես՝ Կամուրջ (այլ կիրառումներ)
Կամուրջ
Անգլերեն անվանում` Bridge
Տեսակ` Կառուցվածքային
Նշանակություն` Աբստրակցիան և իրականացումը միմյանցից բաժանելու համար։
Կառուցվածք` Bridge UML class diagram.svg
Կիրառություն` Երբ աբստրակցիան և իրականցումը պետք է փոփոխվեն միմյանցից անկախ
Նկարագրությունը ԳօՖի
"Design Patterns" գրքում`
Այո

Կամուրջ (անգլ.՝ Bridge), կառուցվածքային նախագծման ձևանմուշ, որն օգտագործվում է աբստրակցիան և իրականացումը միմյանցից բաժանելու համար, որպեսզի վերջիններս հնարավոր լինի փոփոխել միմյանցից անկախ։[1] Կամուրջ ձևանմուշը, որպեսզի բաժանի սպասարկումը տարբեր դասերի միջև, օգտագործում է ինկապսուլյացիա, ագրեգացում և նույնիսկ ժառանգում։

Ընդհանուր հասկացողություններ[խմբագրել | խմբագրել կոդը]

  • Client - հայցող
  • Instance - նմուշ
  • Implementation - իրականացում
  • Product - արգասիք

Նպատակ[խմբագրել | խմբագրել կոդը]

Օբյեկտ կողմնորոշված ծրագրավորման մեջ դասի հաճախակի փոփոխության դեպքում շատ օգտակար է դառնում ծրագիրը փոփոխման ենթարկել՝ մինիմալ տեղեկություններ ունենալով ծրագրի իրականացման մասին։ Կամուրջ ձևանմուշը օգտակար է նրանով, որ հաճախակի փոփոխվում է ոչ միայն դասը, այլև այն, ինչ անում է այդ դասը (դասի ֆունկցիոնալությունը)։

Կառուցվածք[խմբագրել | խմբագրել կոդը]

Bridge UML class diagram.svg

Abstraction (աբստրակտ դաս)
հայտարարում է աբստրակտ ինտերֆեյս
Սպասարկում է Implementor հղմանը:
RefinedAbstraction (նորմալ դաս)
Ընդարձակում է Abstraction-ի հայտարարած ինտերֆեյսը
Implementor (ինտերֆեյս)
հայտարարում է ինտերֆեյս դասերի իրականացման համար
ConcreteImplementor (նորմալ դաս)
իրականացնում է Implementor ինտերֆեյսը
Կամուրջը LePUS3-ում (legend)

Օրինակներ[խմբագրել | խմբագրել կոդը]

C#[խմբագրել | խմբագրել կոդը]

Կամուրջ ձևանմուշը օբյեկտը ստեղծում է ծառատիպ կառուցվածքով։ Այն առանձնացնում է աբստրակցիան և իրականացումը։ Այստեղ աբստրակցիան իրենից ներկայացնում է հայցողին որտեղից պետք է կանչվեն օբյեկտները։ C # լեզվով օրինակը կարելի է տեսնել ստորև.

//IVSR: Bridge pattern example
# region The Implementation

    // Helps in providing truly decoupled architecture
    public interface IBridge
    {
        void Function1();
        void Function2();
    }

    public class Bridge1 : IBridge
    {

        #region IBridge Members

        public void Function1()
        {
            throw new NotImplementedException();
        }

        public void Function2()
        {
            throw new NotImplementedException();
        }

        #endregion
    }

    public class Bridge2 : IBridge
    {
        #region IBridge Members

        public void Function1()
        {
            throw new NotImplementedException();
        }

        public void Function2()
        {
            throw new NotImplementedException();
        }

        #endregion
    }
    # endregion

    # region Abstraction
    public interface IAbstractBridge
    {
        void CallMethod1();
        void CallMethod2();
    }

    public class AbstractBridge : IAbstractBridge 
    {
        public IBridge bridge;

        public AbstractBridge(IBridge bridge)
        {
            this.bridge = bridge;
        }
        #region IAbstractBridge Members

        public void CallMethod1()
        {
            this.bridge.Function1();
        }

        public void CallMethod2()
        {
            this.bridge.Function2();
        }

        #endregion
    }
    # endregion

Ինչպես դուք կարող եք տեսնել կամրջի դասերը իրականացումներ են, որոնք օգտագործում են կողմնորոշված ճարտարապետությամբ միևնույն ինտերֆեյսը օբյեկտներ ստեղծելու համար։ Մյուս կողմից աբստրակցիան իր օբյեկտը ստանում է իրականացման փուլում՝ մեթոդի աշխատանքի ժամանակ։ Այսպեսով իրականցումն ու աբստրակցիան միմյանցից անկախ են։

C++[խմբագրել | խմբագրել կոդը]

#include <iostream.h>
#include <iomanip.h> 
#include <string.h>

class TimeImp 
{ 
public: 
 TimeImp(int hr, int min) 
 { 
  hr_ = hr; 
  min_ = min; 
 } 
 virtual void tell() 
 { 
   cout << "time is " << setw(2) << setfill(48) << hr_ << min_ << endl; 
 } 
protected: 
  int hr_, min_; 
};

class CivilianTimeImp: public TimeImp 
{ 
public: 
 CivilianTimeImp(int hr, int min, int pm): TimeImp(hr, min) 
 { 
  if (pm) 
     strcpy(whichM_, " PM"); 
   else 
     strcpy(whichM_, " AM"); 
 } 
 /* virtual */ void tell() 
 {
    cout << "time is " << hr_ << ":" << min_ << whichM_ << endl; 
 } 
protected: 
 char whichM_[4]; 
};

class ZuluTimeImp: public TimeImp 
{ 
public: 
 ZuluTimeImp(int hr, int min, int zone): TimeImp(hr, min) 
 { 
  if (zone == 5) 
      strcpy(zone_, " Eastern Standard Time"); 
  else if (zone == 6) 
      strcpy(zone_, " Central Standard Time"); 
 }

 /* virtual */ void tell() 
 {
   cout << "time is " << setw(2) << setfill(48) << hr_ << min_ << zone_ << endl; 
 } 
protected: 
 char zone_[30]; 
};

class Time 
{ 
public: 
 Time(){} Time(int hr, int min) 
 { 
  imp_ = new TimeImp(hr, min); 
 } 
  virtual void tell() 
 { 
  imp_->tell();
 }

protected: 
 TimeImp *imp_; 
};

class CivilianTime: public Time 
{ 
public:
 CivilianTime(int hr, int min, int pm)
 {
   imp_ = new CivilianTimeImp(hr, min, pm);
 }
};

class ZuluTime: public Time 
{ 
public:
 ZuluTime(int hr, int min, int zone)
 {
   imp_ = new ZuluTimeImp(hr, min, zone);
 } 
};

int main() 
{
 Time *times[3];

 times[0] = new Time(14, 30);
 times[1] = new CivilianTime(2, 30, 1);
 times[2] = new ZuluTime(14, 30, 6);
 
for (int i = 0; i < 3; i++) 
    times[i]->tell();

return 0;
}

Ծանոթագրություններ[խմբագրել | խմբագրել կոդը]

  1. Gamma, E, Helm, R, Johnson, R, Vlissides, J: Design Patterns, page 151. Addison-Wesley, 1995