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

Անվան այլ կիրառումների համար տե՛ս՝ Կամուրջ (այլ կիրառումներ)

Կամուրջ
Տեսակ	Կառուցվածքային
Նշանակություն	Աբստրակցիան և իրականացումը միմյանցից բաժանելու համար։
Կառուցվածք
Կիրառություն	Երբ աբստրակցիան և իրականցումը պետք է փոփոխվեն միմյանցից անկախ
Նկարագրությունը ԳօՖի "Design Patterns" գրքում	Այո

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

Ընդհանուր հասկացողություններ

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

Նպատակ

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

Կառուցվածք

Abstraction (աբստրակտ դաս)

հայտարարում է աբստրակտ ինտերֆեյս

Սպասարկում է Implementor հղմանը։

RefinedAbstraction (նորմալ դաս)

Ընդարձակում է Abstraction-ի հայտարարած ինտերֆեյսը

Implementor (ինտերֆեյս)

հայտարարում է ինտերֆեյս դասերի իրականացման համար

ConcreteImplementor (նորմալ դաս)

իրականացնում է Implementor ինտերֆեյսը

Կամուրջը LePUS3-ում (legend Archived 2018-03-14 at the Wayback Machine.)

Օրինակներ

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