imported>Ulanwp: Fehlenden Sprachparameter eingefügt

2026-02-19T16:58:13Z

Fehlenden Sprachparameter eingefügt

Neue Seite

Als '''Datenkapselung''' ({{enS|encapsulation}}, nach [[David Parnas]] auch bekannt als {{lang|en|''information hiding''}}) bezeichnet man in der [[Programmierung]] das Verbergen von [[Daten]] oder [[Information|Informationen]] vor dem Zugriff von außen. Der direkte Zugriff auf die interne [[Datenstruktur]] wird unterbunden und erfolgt stattdessen über definierte [[Schnittstelle (Objektorientierung)|Schnittstellen]] ([[Black Box (Systemtheorie)|Black-Box-Modell]]).

== Herleitung ==
Datenkapselung ist ein lange bekanntes Prinzip innerhalb der [[Strukturierte Programmierung|strukturierten]] und [[Modulare Programmierung|modularen Programmierung]]. Zentrales Modell ist hier der [[Abstrakter Datentyp|abstrakte Datentyp]], in dem Daten in einer [[Datenstruktur]] zusammengefasst sind, auf die nur über festgelegte [[Zugriffsfunktion|Zugriffsfunktionen]] ([[Prozedur (Programmierung)|Prozeduren]]) zugegriffen werden kann. In der tatsächlichen [[Programmierung]] wird der [[Abstrakter Datentyp|abstrakte Datentyp]] auf verschiedene Weisen implementiert.

Ein anderes Beispiel in modernen [[Programmiersprache|Programmiersprachen]] ist das Verbergen von Daten innerhalb von [[Gültigkeitsbereich]]en. Jede Teilstruktur eines Programms (Hauptblock, [[Prozedur (Programmierung)|Prozeduren]], [[Funktion (Programmierung)|Funktionen]], [[Unterprogramm|Unterprogramme]], …) definiert einen solchen Bereich, so dass eine Gültigkeitshierarchie entsteht. Deklarierte Daten sind nur innerhalb des umgebenden und in allen tieferen Bereichen sichtbar und gültig. Für einen höheren Bereich bleiben sie verborgen.

== Datenkapselung im objektorientierten Paradigma ==
Kapselung ist auch ein wichtiges Prinzip der [[Objektorientierte Programmierung#Konzepte|objektorientierten Programmierung]]. Als Kapselung bezeichnet man den kontrollierten Zugriff auf [[Methode (Programmierung)|Methoden]] bzw. [[Attribut (Programmierung)|Attribute]] von [[Klasse (Objektorientierung)|Klassen]]. Klassen können den internen Zustand anderer Klassen nicht in unerwarteter Weise lesen oder ändern. Eine Klasse hat eine [[Schnittstelle (Objektorientierung)|Schnittstelle]], die darüber bestimmt, auf welche Weise mit der Klasse interagiert werden kann. Dadurch wird das Umgehen von [[Invariante (Informatik)|Invarianten]] des [[Computerprogramm|Programms]] verhindert.

Vom Innenleben einer Klasse soll der Verwender – gemeint sind sowohl die [[Algorithmus|Algorithmen]], die mit der [[Klasse (Objektorientierung)|Klasse]] arbeiten, als auch der [[Programmierer]], der diese entwickelt – möglichst wenig wissen müssen ''(Geheimnisprinzip)''. Durch die Kapselung werden nur Angaben über das „Was“ (Funktionsweise) einer Klasse nach außen sichtbar, nicht aber das „Wie“ (die interne Darstellung). Dadurch wird eine [[Schnittstelle]] nach außen definiert und zugleich dokumentiert.

=== Verwendete Zugriffsarten ===

Die [[Unified Modeling Language]] als De-facto-Standardnotation erlaubt die Modellierung folgender Zugriffsarten (in Klammern die Kurznotation der [[Unified Modeling Language|UML]]):
; public (<code>+</code>):Zugreifbar für alle [[Objekt (Programmierung)|Objekte]],
; private (<code>-</code>):Nur für Objekte der eigenen [[Klasse (Objektorientierung)|Klasse]] zugreifbar,
; protected (<code>#</code>):Nur für Objekte der eigenen Klasse und von [[Abgeleitete Klasse|abgeleiteten Klassen]] dieser Klasse zugreifbar,
; package (<code>~</code>): erlaubt den Zugriff für alle Elemente innerhalb des eigenen Pakets.

''Anmerkung:'' Die Handhabung des [[Schlüsselwort (Programmierung)|Schlüsselwortes]] ''package'' ist in den verschiedenen [[Programmiersprache|Programmiersprachen]] unterschiedlich. Ersetzung in der jeweiligen Sprache:
* [[C-Sharp|C#]]: ''internal''
* [[Visual Basic .NET]]: ''friend''
* [[Java (Programmiersprache)|Java]]: Keine Definition bedeutet Package-Zugriff (Default).

Die Möglichkeiten zur Spezifizierung der Zugreifbarkeit sind je nach [[Programmiersprache]] unterschiedlich.

=== Vorteile ===
* Da die Implementierung einer [[Klasse (Objektorientierung)|Klasse]] anderen Klassen nicht bekannt ist, kann die Implementierung geändert werden, ohne die Zusammenarbeit mit anderen Klassen zu beeinträchtigen.
* Es ergibt sich eine erhöhte Übersichtlichkeit, da nur die öffentliche Schnittstelle einer Klasse betrachtet werden muss.
* Beim Zugriff über eine [[Zugriffsfunktion]] spielt es von außen keine Rolle, ob diese Funktion 1:1 im Inneren der Klasse existiert, das Ergebnis einer Berechnung ist oder möglicherweise aus anderen Quellen, z. B. einer [[Datei]] oder [[Datenbank]], stammt.
* Deutlich verbesserte [[Testbarkeit]], Stabilität und Änderbarkeit der [[Software]] bzw. deren [[Modul (Software)|Module]].
* Reduktion der Anzahl der möglichen unerwünschten Interaktionen zwischen Programmteilen. Enthält ein [[Computersprache|Programm]] N [[Variable (Programmierung)|Variablen]] und M [[Funktion (Programmierung)|Funktionen]], gibt es <math>\mathcal{O}(N\cdot M)</math> mögliche Interaktionen. In der Regel sind aber nur <math>\mathcal{O}(N+M)</math> Interaktionen tatsächlich erwünscht. Dies spielt bei der Fehlersuche eine Rolle, weil sich Fehler meist dadurch manifestieren, dass eine Variable einen falschen Wert enthält, und man zur Eingrenzung der Fehlerursache wissen muss, welche Funktionen auf die Variable Zugriff haben. Die Datenkapselung schränkt den zu untersuchenden Programmabschnitt von vornherein auf sehr wenige Funktionen ein.

=== Nachteile ===
* In Abhängigkeit vom Anwendungsfall Geschwindigkeitseinbußen durch den Aufruf von [[Zugriffsfunktion|Zugriffsfunktionen]]. Der direkte Zugriff auf die [[Datenelement|Datenelemente]] wäre schneller.
* Zusätzlicher Programmieraufwand für die Erstellung von Zugriffsfunktionen.
Die interne Darstellung eines [[Objekt (Programmierung)|Objekts]] wird im Allgemeinen außerhalb der Objektdefinition ausgeblendet. Normalerweise können nur die eigenen Methoden des Objekts seine direkt untersuchen oder bearbeiten. Durch das Ausblenden der internen Daten des Objekts wird seine Integrität geschützt, indem verhindert wird, dass Benutzer die internen Daten der Komponente in einen ungültigen oder inkonsistenten Zustand versetzen. Ein vermeintlicher Vorteil der Kapselung besteht darin, dass sie die Systemkomplexität verringern und damit die Robustheit erhöhen kann, indem der Entwickler die gegenseitigen Abhängigkeiten zwischen Softwarekomponenten begrenzen kann.

Einige [[Objektorientierte Programmiersprache|objektorientierte Programmiersprachen]] wie Ruby erlauben den Zugriff nur über Objektmethoden, aber die meisten, z. B. C#. C++ und Java, bieten dem Programmierer ein gewisses Maß an Kontrolle darüber, was verborgen ist, normalerweise über Schlüsselwörter wie ''public'' und ''private''. Das Ausblenden von Informationen wird erreicht, indem eine kompilierte Version des Quellcodes bereitgestellt wird, die über eine Header-Datei verbunden ist.<ref name="Pierce">{{cite journal |first=Benjamin |last=Pierce |year=2002 |title=Types and Programming Languages |journal=MIT Press |language=en}}</ref>

== Beispiele ==
Das folgende Beispiel in der [[Programmiersprache]] [[C-Sharp|C#]] zeigt, wie der Zugriff auf ein [[Attribut (Programmierung)|Attribut]] durch die Verwendung des [[Schlüsselwort (Programmierung)|Schlüsselworts]] <code>private</code> eingeschränkt werden kann:
<syntaxhighlight lang="csharp">
class Program
{
public class Konto
{
private decimal kontostand = 500.00m;

public decimal gibKontostand()
{
return kontostand;
}
}

static void Main()
{
Konto meinKonto = new Konto();
decimal meinKontostand = meinKonto.gibKontostand();

/* Diese Main Methode kann den Kontostand mit der öffentlichen Methode "gibKontostand", die von der Klasse "Konto" zur Verfügung gestellt wird, abfragen, aber sie kann den Wert des Attributs "kontostand" nicht ändern*/
}
}
</syntaxhighlight>

Das folgende Beispiel ist in der [[Programmiersprache]] [[Java (Programmiersprache)|Java]] implementiert:
<syntaxhighlight lang="java">
public class Angestellter
{
private BigDecimal salary = new BigDecimal(50000.00);

public BigDecimal gibLohn()
{
return salary;
}

public static void main()
{
Angestellter angestellter = new Angestellter();
BigDecimal lohn = angestellter.gibLohn();
}
}
</syntaxhighlight>

Die Kapselung ist auch in nicht objektorientierten [[Programmiersprache|Programmiersprachen]] möglich. In [[C (Programmiersprache)|C]] kann beispielsweise eine Struktur in der öffentlichen [[Programmierschnittstelle]] über die [[Header-Datei]] für eine Reihe von Funktionen deklariert werden, die mit einem [[Datenelement]] arbeiten, das Datenelement enthält, auf die Clients der Programmierschnittstelle mit dem [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>extern</code> nicht zugreifen können.<ref>{{cite book |first1=K. N. |last1=King |title=C Programming: A Modern Approach |edition=2. |date=2008 |publisher=W. W. Norton & Company |language=en |isbn=978-0-393-97950-3 |page=464}}</ref>
<syntaxhighlight lang="c">
// Header file "api.h"

struct Entity; // Opaque structure with hidden members

// API functions that operate on 'Entity' objects
extern struct Entity * open_entity(int id);
extern int process_entity(struct Entity *info);
extern void close_entity(struct Entity *info);
// extern keywords here are redundant, but don't hurt.
// extern defines functions that can be called outside the current file, the default behavior even without the keyword
</syntaxhighlight>

== Einzelnachweise ==
<references />

{{Navigationsleiste Prinzipien objektorientierten Designs}}

[[Kategorie:Programmierkonzept]]

Datenkapselung (Programmierung) - Versionsgeschichte

imported>Ulanwp: Fehlenden Sprachparameter eingefügt