imported>Invisigoth67: typo

2024-11-14T07:20:58Z

typo

Neue Seite

Der '''Adapter''' ({{enS|adapter pattern}}) – auch die '''Hüllenklasse'''<ref>{{Toter Link |url=http://informatik.unibas.ch/lehre/hs10/cs101/folien/17_GenericProg_oldStyle.pdf |date=2024-08 |text=Generic Programming without Generics from JAVA5 |fix-attempted=1 |checked=RucolaSpacecat}} (PDF; 33 kB) Departement Informatik; Stand: 10. Juli 2011.</ref> oder der '''Wrapper''' (v. engl. {{lang|en|''wrapper''}} ‚Verpackung‘, ‚Umschlag‘) genannt – ist ein [[Entwurfsmuster]] aus dem Bereich der [[Softwareentwicklung]], das zur Kategorie der [[Strukturmuster]] (engl. {{lang|en|''structural patterns''}}) gehört. Das Muster dient zur Übersetzung einer [[Schnittstelle (Objektorientierung)|Schnittstelle]] in eine andere. Dadurch wird die Kommunikation von [[Klasse (Objektorientierung)|Klassen]] mit zueinander inkompatiblen Schnittstellen ermöglicht.<ref>{{Literatur|Autor=[[Erich Gamma]], [[Richard Helm]], [[Ralph Johnson]], [[John Vlissides]]| Titel=Entwurfsmuster| Auflage=5| Verlag=[[Addison-Wesley]]| Ort=| Jahr=1996| ISBN=3-8273-1862-9|Seiten=171}}</ref> Es ist ein Entwurfsmuster der sogenannten ''GoF-Muster'' (''{{lang|en|Gang of Four}}'', siehe [[Entwurfsmuster (Buch)|Viererbande]]).

== Verwendung ==
Der Adapter findet Anwendung, wenn eine existierende Klasse verwendet werden soll, deren Schnittstelle nicht der benötigten Schnittstelle entspricht. Dies tritt insbesondere dann auf, wenn Klassen, die zur [[Wiederverwendung]] konzipiert wurden – wie Werkzeugsammlungen oder Klassenbibliotheken – verwendet werden sollen. Diese stellen ihre Dienste durch klar definierte Schnittstellen zur Verfügung, die in der Regel nicht geändert werden sollen und häufig auch nicht geändert werden können, da sie von Dritten stammen.
Des Weiteren wird der Adapter bei der Erstellung wiederverwendbarer Klassen benutzt, wenn diese mit unabhängigen oder nichtvorhersehbaren Klassen zusammenarbeiten sollen.

== UML-Diagramm ==
Die sogenannte „{{lang|en|Gang of Four}}“ ([[Viererbande (Softwareentwicklung)|Viererbande]]) beschreibt zwei Realisierungsalternativen. Die erste ist der Adapter mit Delegation (der sogenannte ''Objektadapter''), die zweite der Adapter mit Vererbung (''Klassenadapter'').

=== Adapter mit Delegation (Objektadapter) ===
Hierbei hat der Adapter eine Assoziation zu der zu adaptierenden Klasse und leitet die Anfragen per [[Delegation (Softwareentwicklung)|Delegation]] weiter.

Der Vorteil ist, dass der Adapter und der dahinterliegende Dienst ausgetauscht werden können; dafür muss die gesamte genutzte Schnittstelle implementiert werden, auch wenn nur ein Teil der Implementierung angepasst werden soll.

[[Datei:Objektadapter.svg|zentriert|Objektadapter in UML-Notation]]

Objektadapter sind auch als ''Hüllenklasse'' oder ''Wrapper-Klasse'' bekannt. Dabei können nicht nur andere Klassen gekapselt werden, sondern auch primitive Datentypen oder prozedurale Programmierbibliotheken.

==== Hüllenklassen für primitive Datentypen ====
Eine Anwendung für Hüllenklassen in [[Objektorientierte Programmiersprache|objektorientierten Programmiersprachen]] ist, Klassen für Grunddatentypen zur Verfügung zu stellen, um die Handhabung zu vereinfachen und zusätzliche [[Funktion (Programmierung)|Funktionen]] zur Verfügung zu stellen. So gibt es z. B. in der Programmiersprache [[Java (Programmiersprache)|Java]] für den Typ <code>int</code> die Klasse <code>Integer</code>, für <code>[[Char (Datentyp)|char]]</code> die Klasse <code>Character</code> oder für <code>float</code> die Klasse <code>Float</code> (entsprechend auch <code>Byte</code>, <code>Short</code>, <code>Long</code>, <code>Boolean</code> und <code>Double</code>). Diese Hüllenklassen ermöglichen den objektorientierten Umgang mit primitiven Datentypen, zum Beispiel, um sie in ein [[Reflexion (Programmierung)|Reflexionskonzept]] einzubinden.

Um die Verwendung von Hüllenklassen zu vereinfachen, wurde in Java 5 das so genannte ''Autoboxing'' oder ''Boxing'' eingeführt. Diese Technik ermöglicht die Verwendung von Hüllenklassen in der von primitiven Datentypen gewohnten Form. Statt der Objekterzeugung mittels <code>Integer i = new Integer(100)</code> kann einfach die Schreibweise <code>Integer i = 100</code> genutzt werden. Ebenfalls kann die Referenzvariable <code>i</code> genutzt werden, als wäre sie eine gewöhnliche <code>int</code>-Variable.<ref name="java_autoboxing">{{Toter Link |url=http://www.oracle.com/technetwork/articles/javase/j2se15-141062.html |date=2024-08 |text=Java 5 neue Fähigkeiten, insbesondere Autoboxing}}; [[Oracle]]</ref>
Die einfache Schreibweise und bessere Lesbarkeit gehen auf Kosten einer erheblich schlechteren Ausführungsgeschwindigkeit.

==== Hüllenklassen für prozedurale Bibliotheken ====
Eine weitere wichtige Anwendung ist die Anpassung einer prozeduralen Bibliothek an ein objektorientiertes Softwaresystem. Hierbei werden die funktionsorientierten Dienste der Bibliothek in ein oder mehrere Objekte [[Datenkapselung (Programmierung)|gekapselt]]. Diese Anwendungsform ist häufig als Entwurfsmuster [[Fassade (Entwurfsmuster)|Fassade]] zu finden.

=== Adapter mit Vererbung (Klassenadapter) ===
Ein Klassenadapter wird mit Hilfe von [[Mehrfachvererbung]] realisiert. Zum einen erbt er die Implementierung der zu adaptierenden Klasse. Zum anderen die zu implementierende Schnittstelle. Der Aufruf erfolgt dann durch [[Delegation (Softwareentwicklung)|Selbstdelegation]].

[[Datei:Klassenadapter.svg|zentriert|Klassenadapter in UML-Notation]]

Ein Klassenadapter kann dann sinnvoll eingesetzt werden, wenn die Programmiersprache (wie beispielsweise [[C++]]) die erforderlichen Eigenschaften (Mehrfachvererbung, private Vererbung<ref> {{Internetquelle |url=http://www.dietmar-kuehl.de/mirror/c++-faq/private-inheritance.html  |titel=''private inheritance'' |werk=dietmar-kuehl.de |abruf=2019-06-23}}</ref>) aufweist. Programmiersprachen ohne private und Mehrfachvererbung sind für diese Art von Adapter eher ungeeignet. Der Versuch, diese Beschränkung über die Kombination von Klassenvererbung und Interface-Implementierung zu umgehen, führt dazu, dass die Adapterklasse ihren Klienten alle Methoden zur Verfügung stellt. Das Konstrukt kann zwar als Adapter verwendet werden, ist aber kein Adapter im Sinne des [[Viererbande (Softwareentwicklung)|GoF]]-Buchs, der eine Schnittstelle in eine andere überführt.

== Vor- und Nachteile ==
Die Vorteile eines Klassenadapters bestehen darin, dass er sich genau einer Zielklasse anpasst und dadurch nur das Verhalten der Zielklasse überschreiben kann. Der Objektadapter kann auch Unterklassen mit anpassen.

Nachteilig wirkt sich aus, dass ein Klassenadapter nicht zur automatischen Anpassung von Unterklassen verwendet werden kann.

== Akteure ==
Der Dienst bietet wiederzuverwendende Dienstleistungen mit fest definierter Schnittstelle an. Der Klient nutzt Dienste über inkompatible Schnittstellen und greift dabei auf adaptierte Schnittstellen zurück. Das Ziel definiert die Schnittstelle, die der Klient nutzen kann. Der Adapter adaptiert die Schnittstelle des Dienstes auf die Schnittstelle zum Klienten.

== Beispiele ==
=== Allgemein ===
Der Zugriff der Elemente einer [[Grafische Benutzeroberfläche|grafischen Benutzeroberfläche]] auf das dahinterliegende [[Semantisches Datenmodell|Modell]] kann über ''Adapter mit Delegation'' gesteuert werden. So kann beispielsweise eine [[Checkbox]] sowohl einen gepufferten [[Boolean]]-Wert als auch das unmittelbare Ergebnis einer Bedingung anzeigen. Dieses Muster wird unter anderem von [[Smalltalk (Programmiersprache)|Visualworks Smalltalk]] intensiv genutzt.

=== Klassenadapter ===
<syntaxhighlight lang="cpp">
// C++ Code Beispiel

/* Die Schnittstelle, welche der Adapter implementieren soll */
class UsedInterface {
public:
UsedInterface();
virtual void operation() const;
};

/* Die Implementierung, welche der Adapter verwenden soll */
class Adaptee {
public:
Adaptee();
static void adaptedOperation() const;
};

/* Die eigentliche Adapterklasse */
class Adapter : public UsedInterface, private Adaptee {
public:
Adapter();
void operation() const;
};

/* Implementierung des Adapters */
void Adapter::operation() const {
Adaptee::adaptedOperation();
}
</syntaxhighlight>

==== Konkretes Beispiel in C++ ====
Es wurden zwei Bibliotheken gekauft, deren Implementierung nicht einsehbar ist und nicht geändert werden kann. Die erste ist eine Bibliothek für [[algorithmische Geometrie]]. Sie enthält Algorithmen, die auf geometrischen Objekte wie Kreisen, Geraden und Ebenen arbeiten, z. B. einen Algorithmus, der testet, ob sich zwei Kreise schneiden. Die zweite ist eine [[Grafische Benutzeroberfläche|GUI]]-Bibliothek, die ebenfalls Objekte wie Kreise und Geraden kennt und diese auf den Bildschirm zeichnen kann.

Nun soll mit Hilfe der Geometrie-Bibliothek festgestellt werden, ob sich zwei Kreise schneiden, die als Objekte der GUI-Bibliothek vorliegen (bevor sie auf den Bildschirm gemalt werden).

Leider sind die Schnittstellen der beiden Bibliotheken inkompatibel. Sie unterscheiden sich nicht nur in der Bezeichnung der Klassen (<code>Kreis</code> vs. <code>Circle</code>), sondern auch in der Bezeichnung und Semantik der Methoden (<code>getMittelpunkt()</code> vs. <code>getX()</code> und <code>getY()</code>).

Die Algorithmen der Geometrie-Bibliothek arbeiten nur mit der öffentlichen Schnittstelle (dem Interface) der geometrischen Objekte. Ein <code>Kreis</code> beispielsweise muss nur Auskunft über seinen Radius und seinen Mittelpunkt geben können. Er wird durch eine abstrakte Klasse mit den entsprechenden Methoden <code>getRadius()</code> und <code>getMittelpunkt()</code> repräsentiert. Er hat keine Datenelemente für Radius und Mittelpunkt, denn er könnte auch anders festgelegt sein: Durch zwei Punkte auf dem Rand, die sich diametral gegenüberliegen, durch drei Punkte auf dem Rand oder implizit als die Lösungsmenge der Gleichung <math>(y-a)^2+(x-b)^2=r^2</math>. Dadurch werden die Algorithmen unabhängig von der konkreten Darstellung der geometrischen Objekte. Punkte dagegen sind in der Bibliothek (konkret) als Struktur implementiert.

<syntaxhighlight lang="Cpp">
// Bibliothek für algorithmische Geometrie

struct Punkt {
double _x, _y; // der Einfachheit halber public
Punkt(double x, double y) : _x(x), _y(y) {}
};

class Kreis { // abstrakte Klasse, nur Interface
public:
virtual double getRadius() const = 0;
virtual Punkt getMittelpunkt() const = 0;
};

// Die Implementierung dieser Funktion stützt sich rein auf die
// Schnittstelle, also nicht auf konkrete Realisierungen:
bool schneidetKreisKreis(const Kreis& k1, const Kreis& k2) {
double abstandDerKreise = abstand(k1.getMittelpunkt(), k2.getMittelpunkt());
return abstandDerKreise <= (k1.getRadius() + k2.getRadius());
}
</syntaxhighlight>

Die in der GUI-Bibliothek enthaltenen grafischen Objekte können sich auf den Bildschirm zeichnen. Ein <code>Circle</code> ist intern dargestellt durch drei [[Gleitkommazahl]]en, zwei für die Mittelpunkts-Koordinaten und eine für den Radius. Er kann Auskunft über seine Geometrie geben (<code>getX()</code> usw.):

<syntaxhighlight lang="Cpp">
// GUI-Bibliothek

class GraphicalObject {
virtual void draw() = 0; // zeichne dich selbst auf den Bildschirm
};

class Circle : public GraphicalObject {
private:
double _mx, _my; // Mittelpunkt x und y
double _r; // Radius
public:
Circle(double x, double y, double r) : _mx(x), _my(y), _r(r) {}
double getX() const { return _mx; }
double getY() const { return _my; }
double getR() const { return _r; }
void draw() { /* zeichne dich mit Bresenham-Algorithmus */}
};
</syntaxhighlight>

Die Schnittstellen der beiden Bibliotheken sind offensichtlich unterschiedlich. Um nun doch einen <code>Circle</code> in einem der Algorithmen für <code>Kreis</code> benutzen zu können, wird ein Adapter für <code>Circle</code>-Objekte geschrieben. Jedes Adapter-Objekt enthält einen zu adaptierenden <code>Circle</code> und implementiert die Schnittstelle von <code>Kreis</code>:

<syntaxhighlight lang="Cpp">
// Circle-Adapter zur Benutzung eines Circle als Kreis in der
// Geometrie-Bibliothek

class CircleAdapter : public Kreis, private Circle {
public:
CircleAdapter(const Circle& c) : Circle(c.getX(), c.getY(), c.getR()) {}

// Hier wird Circle so adaptiert, dass es auf Kreis passt
double getRadius() const { return getR(); }
Punkt getMittelpunkt() const { return Punkt(getX(), getY()); }
};
</syntaxhighlight>

Nun können zwei <code>Circle</code> aus der GUI-Bibliothek als <code>Kreis</code> gesehen mit dem Algorithmus aus der Geometrie-Bibliothek auf Schnitt getestet werden:

<syntaxhighlight lang="Cpp">
int main() {
// Mit Hilfe der GUI-Bibliothek werden zwei Circles erzeugt
Circle c1 = Circle(1.0, 0.0, 2.0);
Circle c2 = Circle(3.0, 0.0, 2.0);

// dann werden sie in einen Circle-Adapter gesteckt
CircleAdapter c1Adapter(c1);
CircleAdapter c2Adapter(c2);

// anschließend wird die Geometrie-Bibliothek zum Test auf Schnitt benutzt
if (schneidetKreisKreis(c1Adapter, c2Adapter)) {
...
} else {
...
}
}
</syntaxhighlight>

== Verwandte Entwurfsmuster ==
[[Brücke (Entwurfsmuster)|Brücke]] und Adapter sind sich ähnlich. Die Brücke ist jedoch eine gezielte Designentscheidung zur Trennung einer Schnittstelle von ihrer Implementierung, während der Adapter einer nachträglichen Anpassung einer Schnittstelle an eine andere dient.

[[Fassade (Entwurfsmuster)|Fassade]] und Adapter sind eine Form der Hüllenklasse. Die Fassade verbirgt allerdings den Funktionsumfang einer Bibliothek ganz oder teilweise, während der Adapter nur die Schnittstelle verändert.

== Weblinks ==
{{Commonscat|Adapter pattern|Adapter (Entwurfsmuster)}}
{{Wikibooks|Muster: Adapter}}

== Einzelnachweise ==
<references />

{{Navigationsleiste Entwurfsmuster}}

[[Kategorie:Strukturmuster]]
[[Kategorie:Viererbande-Entwurfsmuster]]

Adapter (Entwurfsmuster) - Versionsgeschichte

imported>Invisigoth67: typo