Klasse (objektorientierte Programmierung)

Klasse ist in der Objektorientierung ein abstrakter Oberbegriff für die Beschreibung der gemeinsamen Struktur und des gemeinsamen Verhaltens von realen Objekten (Klassifizierung) im Softwaredesign: reale Objekte werden auf die für die Software wichtigen Merkmale abstrahiert. Im Zusammenspiel mit anderen Klassen ermöglichen sie die Modellierung eines abgegrenzten Systems in der objektorientierten Analyse und dem objektorientierten Design.

Die Klasse dient als Bauplan für Abbildung von realen Objekten in Softwareobjekte, sog. Instanzen. Die Klasse fasst hierfür notwendige Eigenschaften (Attribute) und zur Manipulation der Eigenschaften notwendige Methoden zusammen.

Klassen können von anderen Klassen abgeleitet werden (Vererbung). Dabei erbt die Klasse einige oder alle Eigenschaften (Attribute) und Methoden von der vererbenden Klasse (Basisklasse). Die abgeleitete Klasse (Subklasse) kann Methoden der Basisklasse überschreiben (sofern diese es erlaubt; die Möglichkeit, dies zu verbieten, hängt von der Programmiersprache ab), d. h. die Methode neu implementieren, und eigene Methoden und Daten (Attribute) hinzufügen. Ein Objekt der abgeleiteten Klasse kann überall verwendet werden, wo ein Objekt der Basisklasse erwartet wird (Liskovsches Substitutionsprinzip); überschriebene Methoden werden dann auf der abgeleiteten Klasse ausgeführt (Polymorphie). Weiterhin ist es auch möglich, die vorhandene Basismethode zu erweitern, d. h. den vorhandenen Code der Basisklasse nicht komplett zu überschreiben (durch Neuimplementierung), sondern durch Aufruf der Basisklassenfunktion weiter zu benutzen. Dabei muss dem Programm mittels der korrekten Notation mitgeteilt werden, dass man die Basisklasse aufrufen möchte (in Java z. B. durch Verwendung des Schlüsselwortes „super“, in C++ wird der Klassenname der Basisklasse und zwei Doppelpunkte dem Funktionsaufruf vorangestellt).

Ein ähnliches Werkzeug, welches zum systematischen Verwalten von Attributen verwendet werden kann, ist eine Struktur. Bei Programmiersprachen, welche keine Objektorientierung unterstützen (z. B. C), ist dies die einzige Möglichkeit.

Beispiele

Ein sehr einfaches Beispiel ist das einer Lampe. In der realen Welt gibt es verschiedene Formen von Lampen, z. B. Stehlampen, Schreibtischlampen, Taschenlampen. Jede dieser Lampen hat Eigenschaften (Attribute), wie Farbe, Form und Größe. Für die Abbildung der Lampe in der Software abstrahiert man nun aus den Eigenschaften des realen Objektes „Lampe“ die für den Zweck der Software wichtigen Eigenschaften in eine Klasse. Diese bildet nun mit geeigneten Methoden zur Manipulation der Eigenschaften eine Art Konstruktionsplan.

Ist der Zweck der Software beispielsweise die Simulation eines Experimentes mit einer Lichtquelle, so ist für die Abbildung der Lampe in der Software die Farbe und Form der Lampe uninteressant, wohl aber, ob das Licht an oder aus ist. Für eine Software zur Innenraumplanung eines Gebäudes ist die Eigenschaft, ob das Licht an oder aus ist uninteressant, es interessiert viel mehr Form, Größe und Farbe der Lampe. Ein Objekt Lampe wird daher im Kontext zur Anwendung unterschiedlich klassifiziert:

Die Klasse Lampe in der Simulationssoftware:

• hat das Attribut Licht an/aus
• hat die Methode Lichtschalter

Weitere benötigte Methoden zur Veränderung des Experimentes:

• hat die Methode Lampe hinzufügen
• hat die Methode Lampe entfernen

Die Klasse Lampe in der Innenraumplanungssoftware:

• hat das Attribut Form (z. B. Schreibtischlampe, Stehlampe)
• hat das Attribut Größe (z. B. groß, mittel, klein, hoch)
• hat das Attribut Farbe (z. B. rot, grün, blau)
• hat die Methode Form_ändern
• hat die Methode Größe_ändern
• hat die Methode Farbe_ändern
• hat die Methode Position_ändern

Ebenfalls werden hier Methoden zum Entfernen und Hinzufügen von Lampen benötigt:

• hat die Methode Lampe hinzufügen
• hat die Methode Lampe entfernen

In der jeweiligen Software wird nun durch die Methode hinzufügen eine Lampe erstellt und bekommt einen Namen (z. B. Versuchslampe_1 oder Stehlampe_Wohnzimmer) als Referenz. Über diese kann sie später in der Simulationssoftware ein- und ausgeschaltet bzw. in der Innenraumplanungssoftware in Form, Größe, Farbe oder Position verändert werden.

Programmbeispiel

Das folgende Beispiel ist in der Programmiersprache C++ geschrieben:

 #include <iostream>
 using namespace std;
 
 class Fahrzeug                 
 // Die Klasse "Fahrzeug" ist die Basisklasse.
 {               
   public:
     virtual void bewegen()
     {
       cout << "Fahrzeug wird bewegt.\n";
     }
 };
 
 class Auto : public Fahrzeug 
 // Die Klasse "Auto" ist die abgeleitete Klasse. 
 { 
   public:
     void bewegen()
     {
       cout << "Auto wird bewegt.\n";
     }
 };
 
 void aktion(Fahrzeug &f)
 {
      f.bewegen();
 }
 
 int main()
 {
   Fahrzeug  objekt1;
   Auto      objekt2;
   objekt1.bewegen();
   objekt2.bewegen();
 
   aktion(objekt1);
   aktion(objekt2);
   return 0;
 }

Dieses Programm definiert eine Klasse Fahrzeug und eine davon abgeleitete Klasse Auto.

Die Basisklasse hat eine Methode namens bewegen(), die den Text „Fahrzeug wird bewegt.\n“ auf dem Computerbildschirm ausgibt. Das Schlüsselwort virtual bedeutet in C++ an dieser Stelle „kann überschrieben werden“. Das macht die abgeleitete Klasse dann auch, sie definiert die Methode um, so dass sie „Auto wird bewegt.\n“ ausgibt.

Anschließend folgt die Definition einer eigenständigen Funktion aktion(), die ein Objekt der Basisklasse als Argument bekommt. Auf diesem Objekt wird die Methode bewegen() aufgerufen.

Schließlich folgt das Hauptprogramm, das sowohl ein Objekt der Basisklasse (objekt1) als auch der abgeleiteten Klasse (objekt2) definiert, und auf beide zuerst bewegen() aufruft und danach mit Hilfe von aktion() ebenfalls noch einmal bewegen() für beide Objekte aufruft.

Wird dieses Programm kompiliert und ausgeführt, so erscheint auf dem Bildschirm

 Fahrzeug wird bewegt.
 Auto wird bewegt.
 Fahrzeug wird bewegt.
 Auto wird bewegt.

Auch erkennt man hier, obwohl die Funktion aktion() nur für die Basisklasse definiert ist, kann sie trotzdem mit abgeleiteten Klassen benutzt werden.

Siehe auch

• Liste objektorientierter Programmiersprachen
• Schnittstelle (objektorientierte Programmierung)
• Abstrakte Klasse
• Entwurfsmuster Singleton als Spezialfall einer Klasse