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

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

Օրինակներ
---------

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

```