Inkapsling (programmering)

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 21 september 2016; kontroller kräver 79 redigeringar .

Encapsulation ( eng.  inkapsling , från lat.  in capsula ) - inom datavetenskap , processen att separera de element av abstraktioner som bestämmer dess struktur (data) och beteende (metoder); inkapsling är avsedd att isolera de kontraktuella skyldigheterna för en abstraktion (protokoll/gränssnitt) från deras implementering. I praktiken innebär det att en klass ska bestå av två delar: ett gränssnitt och en implementering. Implementeringen av de flesta programmeringsspråk ( C++ , C# , Java och andra) tillhandahåller en döljningsmekanism som gör att du kan skilja åtkomst till olika delar av komponenten.

Inkapsling ses ofta som ett koncept exklusivt för objektorienterad programmering (OOP) , men i själva verket finns det i stor utsträckning i andra (se postsubtyping och post- och variantpolymorfism ). I OOP är inkapsling nära besläktad med principen om dataabstraktion (inte att förväxla med abstrakta datatyper, vars implementeringar ger inkapsling men är av en annan karaktär). Detta medför i synnerhet skillnader i terminologi i olika källor. I C++- eller Java -gemenskapen anses inkapsling utan att gömma sig generellt som underlägsen. Vissa språk (t.ex. Smalltalk , Python ) implementerar dock inkapsling men ger inte utrymme alls. Andra ( Standard , OCaml ) separerar dessa begrepp strikt som ortogonala och tillhandahåller dem på ett semantiskt annorlunda sätt (se gömma sig i ML-modulspråket ).

Detaljer

I allmänhet, i olika programmeringsspråk, hänvisar termen "inkapsling" till en eller båda av följande notationer samtidigt:

Ordet "inkapsling" kommer från latinet i kapsel  - "placering i skalet." Således kan inkapsling intuitivt förstås som isolering, stänga något främmande för att utesluta påverkan på miljön, säkerställa tillgängligheten av huvudinnehållet, framhäva huvudinnehållet genom att placera allt som stör, sekundärt i någon villkorlig kapsel ( svart låda ).

Exempel

Ada

paket Stacks är typ Stack_Type är privat ; procedur Push ( Stack : in out Stack_Type ; Val : Integer ); privat typ Stack_Data är array ( 1..100 ) av heltal ; _ _ typ Stack_Type är post Max : Heltal := 0,3 ; Data : Stack_Data ; slutpost ; slutstaplar ; _

C++

klass A { offentliga : int a , b ; // offentligt gränssnitt data int Return_Something (); // metod för offentligt gränssnitt privat : int Aa , Ab ; //hidden data void Do_Something (); //dold metod };

Klass A kapslar in egenskaperna Aa, Ab och metoden Do_Something(), som representerar det externa gränssnittet Return_Something, a, b.

C#

Syftet med inkapsling är att säkerställa att ett objekts inre tillstånd är konsekvent. I C# används offentliga egenskaper och metoder för ett objekt för inkapsling. Variabler, med sällsynta undantag, bör inte vara offentligt tillgängliga. Inkapsling kan illustreras med ett enkelt exempel. Anta att vi behöver lagra ett verkligt värde och dess strängrepresentation (till exempel för att inte konvertera varje gång vid frekvent användning). Ett exempel på implementering utan inkapsling är följande:

class NoEncapsulation { public double ValueDouble ; offentlig sträng ValueString ; }

Samtidigt kan vi separat ändra både värdet i sig och dess strängrepresentation, och någon gång kan de inte matcha (till exempel som ett resultat av ett undantag). Implementeringsexempel med användning av inkapsling:

class EncapsulationExample { privat dubbelvärdeDouble ; _ privat sträng valueString ; public double ValueDouble { get { return valueDouble ; } set { värdeDubbel = värde ; valueString = värde . ToString (); } } public string ValueString { get { return valueString ; } set { double tmp_value = Konvertera . ToDouble ( värde ); //ett undantag kan förekomma här valueDouble = tmp_value ; valueString = värde ; } } }

Här kan variablerna valueDouble och valueString endast nås via egenskaperna ValueDouble och ValueString . Om vi ​​försöker tilldela en ogiltig sträng till egenskapen ValueString och ett undantag inträffar vid tidpunkten för konverteringen, kommer de interna variablerna att förbli i samma, konsekventa tillstånd, eftersom undantaget gör att proceduren avslutas.

Delphi

I Delphi, för att skapa dolda fält eller metoder , räcker det att deklarera dem i private.

TMyClass = klass privat FMyField : Heltal ; procedure SetMyField ( const Value : Integer ) ; function GetMyField : Heltal ; public property MyField : Heltal läs GetMyField skriv SetMyField ; slut ;

För att skapa ett gränssnitt för åtkomst till dolda fält introducerade Delphi egenskaper .

PHP

klass A { privat sträng $a ; // dold egendom privat int $b ; // dold egendom privat funktion doSomething () : void //hidden method { //actions } public function returnSomething () : int //public method { //actions } }

I det här exemplet har klass A sina $a- och $b-egenskaper stängda för att förhindra att dessa egenskaper skadas av annan kod som behöver ges skrivskyddad behörighet.

Java

klass först { privat int a ; privat int b ; privat void doSomething () { //hidden method //åtgärder } public int getSomething () { //public metod returnera en ; } }

JavaScript

låt A = funktion () { // privat låt _egenskap ; låt _privateMethod = function () { /* åtgärder */ } // privat metod // offentlig detta . getProperty = function () { // offentligt gränssnitt returnera _egenskap ; } detta . setProperty = funktion ( värde ) { // offentligt gränssnitt _property = värde ; _privateMethod (); } }

eller

låt A = funktion () { // privat låt _egenskap ; låt _privateMethod = function () { /* åtgärder */ } // privat metod // offentlig returnera { } }

eller använda privata fastigheter

klass A { #fastighet ; _ # privateMethod = () => { /* åtgärder */ } få egenskap () { // getter lämna tillbaka detta . #fastighet ; _ } set egenskap ( värde ) { // setter detta . # egenskap = värde ; } }