«Կամուրջ (նախագծման ձևանմուշ)»–ի խմբագրումների տարբերություն

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Content deleted Content added
No edit summary
չ →‎top: կետադրություն և բացատներ, փոխարինվեց: ը ,ո → ը, ո oգտվելով ԱՎԲ
Տող 11. Տող 11.
}}
}}


'''Կամուրջ''' ({{lang-en|Bridge}}), [[Կառուցվածքային նախագծման ձևանմուշներ|կառուցվածքային]] [[Նախագծման ձևանմուշներ|նախագծման ձևանմուշ]], որն օգտագործվում է աբստրակցիան և իրականացումը միմյանցից բաժանելու համար, որպեսզի վերջիններս հնարավոր լինի փոփոխել միմյանցից անկախ։<ref>Gamma, E, Helm, R, Johnson, R, Vlissides, J: ''Design Patterns'', page 151. Addison-Wesley, 1995</ref> Կամուրջ ձևանմուշը ,որպեսզի բաժանի սպասարկումը տարբեր դասերի միջև, օգտագործում է ինկապսուլյացիա, ագրեգացում և նույնիսկ ժառանգում։
'''Կամուրջ''' ({{lang-en|Bridge}}), [[Կառուցվածքային նախագծման ձևանմուշներ|կառուցվածքային]] [[Նախագծման ձևանմուշներ|նախագծման ձևանմուշ]], որն օգտագործվում է աբստրակցիան և իրականացումը միմյանցից բաժանելու համար, որպեսզի վերջիններս հնարավոր լինի փոփոխել միմյանցից անկախ։<ref>Gamma, E, Helm, R, Johnson, R, Vlissides, J: ''Design Patterns'', page 151. Addison-Wesley, 1995</ref> Կամուրջ ձևանմուշը, որպեսզի բաժանի սպասարկումը տարբեր դասերի միջև, օգտագործում է ինկապսուլյացիա, ագրեգացում և նույնիսկ ժառանգում։


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

21:33, 11 Մարտի 2016-ի տարբերակ

Կամուրջ

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

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

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

Նպատակ

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

Կառուցվածք

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