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

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

Օրինակներ

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

Օբյեկտ կողմնորոշված ծրագրավորում
Ինֆորմատիկա
Ինկապսուլյացիա , ծրագրավորման մեխանիզմ , որը սահմանափակում է դասի բաղկացուցիչների ( մեթոդների և դաշտերի ) հասանելիությունը , դարձնում է դրանք գաղտնի , այսինքն ՝ հասանելի միայն դասի ներսում ։ Համարվում է կարևոր գործիք Օբյեկտ կողմնորոշված ծրագրավորման մեջ ՝ պոլիմորֆիզմի , ժառանգման և աբստրակտ տվյալների հետ միասին ։ Օրինակ , ինկապսուլյացված փոփոխականին կարելի է դիմել դասի իրականացման ժամանակ , բայց նրա օգտագործման ժամանակ այդ փոփոխականին դիմել հնարավոր չէ ։ Այն լեզուներում , որոնք աջակցում են փակումները , ինկապսուլյացիան դիտարկվում է որպես հասկացություն , որը բնորոշ չէ միայն օբյեկտ կողմնորոշված ծրագրավորմանը ։ Նույն կերպ , տվյալների աբստրակտ տիպը ( օրինակ , մոդուլները ) առաջարկում է տվյալների թաքցման ինկապսուլյացիայի նման մոդել ։ Օրինակներ 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 ( ) ; } } } Օբյեկտ կողմնորոշված ծրագրավորում Ինֆորմատիկա