Indkapsling (programmering)

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 21. september 2016; checks kræver 79 redigeringer .

Encapsulation ( eng.  indkapsling , fra lat.  in capsula ) - i datalogi , processen med at adskille de elementer af abstraktioner, der bestemmer dens struktur (data) og adfærd (metoder); indkapsling har til formål at isolere de kontraktlige forpligtelser for en abstraktion (protokol/grænseflade) fra deres implementering. I praksis betyder det, at en klasse skal bestå af to dele: en grænseflade og en implementering. Implementeringen af ​​de fleste programmeringssprog ( C++ , C# , Java og andre) giver en skjulemekanisme , der giver dig mulighed for at differentiere adgangen til forskellige dele af komponenten.

Indkapsling ses ofte som et koncept eksklusivt til objektorienteret programmering (OOP) , men faktisk findes det i vid udstrækning i andre (se record subtyping og record and variant polymorphism ). I OOP er indkapsling tæt forbundet med princippet om dataabstraktion (ikke at forveksle med abstrakte datatyper, hvis implementeringer giver indkapsling, men er af en anden karakter). Dette medfører især forskelle i terminologi i forskellige kilder. I C++- eller Java -fællesskabet betragtes indkapsling uden at skjule generelt som ringere. Nogle sprog (f.eks. Smalltalk , Python ) implementerer dog indkapsling, men giver slet ikke mulighed for at skjule dem. Andre ( Standard , OCaml ) adskiller disse begreber strengt som ortogonale og giver dem på en semantisk anderledes måde (se skjul i ML-modulsproget ).

Detaljer

Generelt i forskellige programmeringssprog refererer udtrykket "indkapsling" til en eller begge af følgende notationer på samme tid:

Ordet "indkapsling" kommer fra latin i kapsel  - "placering i skallen." Således kan indkapsling intuitivt forstås som isolation, at lukke noget fremmed for at udelukke indflydelse på miljøet, sikre tilgængeligheden af ​​hovedindholdet, fremhæve hovedindholdet ved at placere alt forstyrrende, sekundært i en eller anden betinget kapsel ( black box ).

Eksempler

Ada

pakke Stacks er type Stack_Type er privat ; procedure Push ( Stack : in out Stack_Type ; Val : Integer ); privat type Stack_Data er array ( 1..100 ) af heltal ; _ _ type Stack_Type er record Max : Heltal := 0,3 ; Data : Stack_Data ; slutrekord ; ende Stakke ;

C++

klasse A { offentligt : int a , b ; // offentlig interface data int Return_Something (); // offentlig grænseflade metode privat : int Aa , Ab ; //skjulte data void Gør_Noget (); //skjult metode };

Klasse A indkapsler egenskaberne Aa, Ab og Do_Something()-metoden, der repræsenterer den eksterne grænseflade Return_Something, a, b.

C#

Formålet med indkapsling er at sikre, at den indre tilstand af et objekt er konsistent. I C# bruges offentlige egenskaber og metoder for et objekt til indkapsling. Variabler, med sjældne undtagelser, bør ikke være offentligt tilgængelige. Indkapsling kan illustreres med et simpelt eksempel. Antag, at vi skal gemme en reel værdi og dens strengrepræsentation (for eksempel for ikke at konvertere hver gang i tilfælde af hyppig brug). Et eksempel på implementering uden indkapsling er som følger:

class NoEncapsulation { public double ValueDouble ; offentlig streng ValueString ; }

Samtidig kan vi separat ændre både værdien selv og dens strengrepræsentation, og på et tidspunkt kan de ikke matche (f.eks. som følge af en undtagelse). Implementeringseksempel ved hjælp af indkapsling:

klasse EncapsulationExample { private double valueDouble ; privat streng valueString ; public double ValueDouble { get { return valueDouble ; } sæt { værdiDouble = værdi ; valueString = værdi . ToString (); } } public string ValueString { get { return valueString ; } set { double tmp_value = Konverter . ToDouble ( værdi ); //en undtagelse kan forekomme her valueDouble = tmp_value ; værdistreng = værdi ; } } }

Her kan variablerne valueDouble og valueString kun tilgås via egenskaberne ValueDouble og ValueString . Hvis vi forsøger at tildele en ugyldig streng til egenskaben ValueString , og der opstår en undtagelse på konverteringstidspunktet, vil de interne variable forblive i den samme, konsistente tilstand, da undtagelsen får proceduren til at afslutte.

Delphi

I Delphi, for at oprette skjulte felter eller metoder , er det nok at erklære dem i private.

TMyClass = klasse privat FMyField : Heltal ; procedure SetMyField ( const Value : Integer ) ; funktion GetMyField : Heltal ; public property MyField : Heltal læs GetMyField skriv SetMyField ; ende ;

For at skabe en grænseflade til adgang til skjulte felter introducerede Delphi egenskaber .

PHP

klasse A { privat streng $a ; // skjult ejendom privat int $b ; // skjult ejendom privat funktion doSomething () : void //hidden method { //actions } offentlig funktion returnSomething () : int //public metode { //actions } }

I dette eksempel har klasse A sine $a og $b egenskaber lukket for at forhindre disse egenskaber i at blive beskadiget af anden kode, der skal have skrivebeskyttet tilladelse.

Java

klasse første { privat int a ; privat int b ; privat void doSomething () { //skjult metode //handlinger } public int getSomething () { //public metode returnere en ; } }

JavaScript

lad A = funktion () { // privat lad _ejendom ; lad _privateMethod = function () { /* handlinger */ } // privat metode // offentlig dette . getProperty = function () { // offentlig grænseflade returnere _egenskab ; } dette . setProperty = funktion ( værdi ) { // offentlig grænseflade _egenskab = værdi ; _privateMethod (); } }

eller

lad A = funktion () { // privat lad _ejendom ; lad _privateMethod = function () { /* handlinger */ } // privat metode // offentlig returnere { } }

eller ved at bruge private ejendomme

klasse A { #ejendom ; _ # privatMethod = () => { /* handlinger */ } få ejendom () { // getter returnere dette . #ejendom ; _ } sæt egenskab ( værdi ) { // setter dette . # ejendom = værdi ; } }