Ինկապսուլյացիա (ծրագրավորում)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Jump to navigation Jump to search
1rightarrow blue.svgԱյս հոդվածը օբյեկտ կողմնորոշված ծրագրավորման հասկացության մասին է։ Այլ գործածությունների համար այցելեք Ինկապսուլյացիա (այլ կիրառումներ)։

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

Այն լեզուներում, որոնք աջակցում են փակումները, ինկապսուլյացիան դիտարկվում է որպես հասկացություն, որը բնորոշ չէ միայն օբյեկտ կողմնորոշված ծրագրավորմանը։ Նույն կերպ, տվյալների աբստրակտ տիպը (օրինակ, մոդուլները) առաջարկում է տվյալների թաքցման ինկապսուլյացիայի նման մոդել։

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

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

class A
{
 public:
   int a, b; // բաց միջերեսի տվյալներ
   int ReturnSomething(); // բաց միջերեսի մեթոդ
 private:
   int Aa, Ab; // թաքնված տվյալներ
   void Do_Something(); // թաքնված մեթոդ
};

А դասը ինկապսուլյացնում է Aa, Ab հատկությունները և Do_Something() մեթոդը՝ ներկայացնելով ReturnSomething, a, b արտաքին միջերեսները։

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

Ինկապսուլյացիայի նպատակն է ապահովել օբյեկտի ներքին վիճակի համաձայնություն։ C#֊ում ինկապսուլյացիայի համար օգտագործվում են օբյեկտի հրապարակային հատկությունները և մեթոդները։ Փոփոխականները, հազվագյուտ բացառություններով, չպետք է լինեն հասանելի բոլորին։ Ինկապսուլյացիան կարելի է դիտարկել մի պարզ օրինակի վրա։ Ենթադրենք, մեզ անհրաժեշտ է պահել իրական արժեքը և դրա տողային ներկայացումը (օրինակ, որպեսզի բազմակի օգտագործման ժամանակ ամեն անգամ չփոխարկել այն)։ Առանց ինկապսուլյացիայի այն կունենար հետևյալ տեսքը՝

    class NoEncapsulation
    {
        public double Value;
        public string ValueString;
    }

Այս դեպքում մենք կարող ենք առանձին փոփոխել ինչպես Value արժեքը, այնպես էլ նրա տողային ներկայացումը, և որոշակի պահի կարող է առաջանալ նրանց չհամապատասխանեցումը (օրինակ, բացառության ժամանակ)։ Խնդիրը ինկապսուլյացիայի կիրառմամբ կունենա հետևյալ տեսքը՝

    class EncapsulationExample
    {
        private double valueDouble;
        private string valueString;

        public double Value
        {
            get { return valueDouble; }
            set 
            {
                valueDouble = value;
                valueString = value.ToString();
            }
        }

        public string ValueString
        {
            get { return valueString; }
            set 
            {
                double tmp_value = Convert.ToDouble(value); // այստեղ կարող է առաջանալ բացառություն
                valueDouble = tmp_value;
                valueString = value;
            }
        }
    }

Այստեղ valueDouble և valueString փոփոխականներին կարելի է հասնել միայն Value և ValueString հատկությունների միջոցով։ Եթե մենք փորձենք վերագրել ValueString հատկությանը ոչ ճիշտ տող և փոխակերպման ժամանակ առաջանա բացառություն, ապա ներքին փոփոխականները կմնան նույն՝ համաձայնեցված վիճակում, քանի որ բացառությունը հանգեցնում է գործընթացի դադարեցման։

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

Delphi֊ում թաքնված դաշտերի կամ մեթոդների ստեղծման համար դրանք բավարար է հայտարարել private բաժնում՝

  TMyClass = class
  private
    FMyField: Integer;
    procedure SetMyField(const Value: Integer);
    function GetMyField: Integer;
  public
    property MyField: Integer read GetMyField write SetMyField;
  end;

Թաքնված դաշտերին հասանելիության միջերեսի ստեղծման համար Delphi֊ում կան հատկություններ։

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

class A
{
 private $a; // թաքնված հատկություն
 private $b; // թաքնված հատկություն
 private function DoSomething() // թաքնված մեթոդ
 {  
  // գործողություններ
 }

 public function ReturnSomething() // բաց միջերես
 { 
  // գործողություններ
 }
};

Այս օրինակում A դասի համար $a և $b հատկությունները փակ են՝ կանխելու համար այդ հատկությունների վնասումը այլ կոդով, որին պետք է տրվի միայն ընթերցման իրավունք։

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

class A {
 private int a;
 private int b;

 private void doSomething() { // թաքնված մեթոդ
  //actions
 }

 public int returnSomething() { // բաց մեթոդ
  return a;
 } 
}

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

var A = function() {
 // private
 var _property;
 var _privateMethod = function() { /* գործողություններ */ } // թաքնված մեթոդ

 // public
 this.getProperty = function() { // բաց միջերես
  return _property;
 }

 this.setProperty = function(value) { // բաց միջերես
  _property = value;
  _privateMethod();
 }
}

կամ

var A = function() {
 // private
 var _property;
 var _privateMethod = function() { /* գործողություններ */ } // թաքնված մեթոդ

 // public
 return {
  getProperty: function() { // բաց միջերես
   return _property;
  },
  setProperty: function(value) { // բաց միջերես
   _property = value;
   _privateMethod();
  }
 }
}