Tokozás (programozás)

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt hozzászólók, és jelentősen eltérhet a 2016. szeptember 21-én felülvizsgált verziótól ; az ellenőrzések 79 szerkesztést igényelnek .

Encapsulation ( eng.  encapsulation , lat.  in capsula ) - a számítástechnikában a szerkezetét (adatokat) és viselkedését (módszereit) meghatározó absztrakciók elemeinek szétválasztásának folyamata; a beágyazás célja, hogy elszigetelje egy absztrakció (protokoll/interfész) szerződéses kötelezettségeit azok megvalósításától. A gyakorlatban ez azt jelenti, hogy egy osztálynak két részből kell állnia: egy interfészből és egy megvalósításból. A legtöbb programozási nyelv ( C++ , C# , Java és mások) megvalósítása rejtőzködő mechanizmust biztosít , amely lehetővé teszi az összetevő különböző részeihez való hozzáférés megkülönböztetését.

A beágyazást gyakran az objektum-orientált programozás (OOP) kizárólagos fogalomnak tekintik , de valójában másoknál is széles körben megtalálható (lásd rekord altípus , rekord és változat polimorfizmus ). Az OOP-ban a beágyazás szorosan összefügg az adatabsztrakció elvével (nem tévesztendő össze az absztrakt adattípusokkal, amelyek implementációi biztosítják a beágyazást, de más jellegűek). Ez különösen a különböző források terminológiai különbségeit vonja maga után. A C++ vagy Java közösségben az elrejtés nélküli beágyazás általában alacsonyabb rendűnek számít. Egyes nyelvek azonban (pl. Smalltalk , Python ) alkalmazzák a beágyazást, de egyáltalán nem biztosítják a rejtést. Mások ( Standard , OCaml ) mereven választják el ezeket a fogalmakat ortogonálisként, és szemantikailag eltérő módon biztosítják őket (lásd az ML modul nyelvében való elrejtés ).

Részletek

Általánosságban elmondható, hogy a különböző programozási nyelvekben a "beágyazás" kifejezés a következő jelölések egyikére vagy mindkettőre vonatkozik egyidejűleg:

A "kapszulázás" szó a latin in capsula  - "elhelyezés a héjban" -ból származik. A beágyazás tehát intuitív módon felfogható izolációként, valami idegen lezárása a környezetre gyakorolt ​​hatás kizárása érdekében, a fő tartalom elérhetőségének biztosítása, a fő tartalom kiemelése úgy, hogy minden zavaró, másodlagos dolgot valamilyen feltételes kapszulába ( black box ) helyezünk.

Példák

Ada

csomag Stacks van type Stack_Type privát ; _ eljárás Push ( Stack : in out Stack_Type ; Val : Integer ); magán Type Stack_Data egy egész számból álló tömb ( 1 .. 100 ) ; type Stack_Type rekord Max : Integer : = 0.3 ; Adatok : Stack_Data ; vége rekord ; vége Stacks ;

C++

A osztály { nyilvános : int a , b ; // nyilvános interfész adatok int Return_Something (); // nyilvános interfész módszer privát : int Aa , Ab ; //rejtett adatok void Do_Something (); //rejtett metódus };

Az A osztály az Aa, Ab tulajdonságokat és a Do_Something() metódust tartalmazza, amelyek a Return_Something, a, b külső interfészt képviselik.

C#

A tokozás célja annak biztosítása, hogy az objektum belső állapota konzisztens legyen. A C#-ban egy objektum nyilvános tulajdonságait és metódusait használják a tokozáshoz. A változók – ritka kivételektől eltekintve – nem lehetnek nyilvánosan elérhetőek. A kapszulázást egy egyszerű példával szemléltethetjük. Tegyük fel, hogy el kell tárolnunk egy valós értéket és annak karakterlánc-ábrázolását (például azért, hogy gyakori használat esetén ne konvertáljunk minden alkalommal). Egy példa beágyazás nélküli megvalósításra a következő:

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

Ugyanakkor magát az Értéket és annak karakterlánc-ábrázolását is külön-külön módosíthatjuk , és egy ponton (például egy kivétel következtében) nem egyezhetnek. Megvalósítási példa tokozással:

class EncapsulationExample { private double valueDouble ; privát karakterlánc valueString ; public double ValueDouble { get { return valueDouble ; } set { valueDouble = érték ; valueString = érték . ToString (); } } public string ValueString { get { return valueString ; } set { double tmp_value = Konvertálás . ToDouble ( érték ); //itt kivétel előfordulhat valueDouble = tmp_value ; valueString = érték ; } } }

Itt a valueDouble és a valueString változók csak a ValueDouble és a ValueString tulajdonságokon keresztül érhetők el . Ha megpróbálunk érvénytelen karakterláncot rendelni a ValueString tulajdonsághoz , és az átalakításkor kivétel történik, akkor a belső változók változatlan, konzisztens állapotban maradnak, mivel a kivétel miatt az eljárás kilép.

Delphi

A Delphiben rejtett mezők vagy metódusok létrehozásához elég deklarálni őket a private.

TMyClass = class private FMyField : Integer ; eljárás SetMyField ( konst Érték : Integer ) ; függvény GetMyField : Integer ; public property MyField : Integer olvasás GetMyField írás SetMyField ; vége ;

A rejtett mezők eléréséhez szükséges felület létrehozásához a Delphi bevezette a tulajdonságokat .

PHP

class A { privát karakterlánc $a ; // rejtett tulajdon privát int $b ; // rejtett tulajdonság privát függvény doSomething () : void //rejtett metódus { //műveletek } public function returnSomething () : int //nyilvános metódus { //műveletek } }

Ebben a példában az A osztály $a és $b tulajdonságai zárva vannak, hogy megakadályozzák, hogy ezeket a tulajdonságokat megsértse más kód, amelyhez csak olvasási engedélyt kell adni.

Java

osztály első { privát int a ; magán int b ; private void doSomething () { //rejtett metódus //műveletek } public int getSomething () { //nyilvános metódus return a ; } }

JavaScript

legyen A = függvény () { // magán let _tulajdon ; legyen _privateMethod = function () { /* műveletek */ } // privát metódus // nyilvános ezt . getProperty = function () { // nyilvános felület return _property ; } ezt . setProperty = függvény ( érték ) { // nyilvános felület _tulajdonság = érték ; _privateMethod (); } }

vagy

legyen A = függvény () { // magán let _tulajdon ; legyen _privateMethod = function () { /* műveletek */ } // privát metódus // nyilvános return { } }

vagy magántulajdon használatával

osztály { _ #tulajdon ; _ # private Method = () => { /* akciók */ } tulajdont kap () { // getter ezt visszaküldeni . #tulajdon ; _ } set property ( value ) { // setter ezt . # tulajdonság = érték ; } }