Klasse (Programmierung)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Unter einer Klasse (auch Objekttyp genannt) versteht man in der objektorientierten Programmierung ein abstraktes Modell bzw. einen Bauplan für eine Reihe von ähnlichen Objekten.

Die Klasse dient als Bauplan für die Abbildung von realen Objekten in Softwareobjekte und beschreibt Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der Objekte. Verallgemeinernd könnte man auch sagen, dass eine Klasse dem Datentyp eines Objekts entspricht. Formal gesehen belegt eine Klasse somit zur Programm-Ausführungszeit keinen Arbeitsspeicher, sondern immer nur die Objekte, die von ihr instanziiert wurden.[Anmerkungen 1]

Vererbung[Bearbeiten]

Klassen können miteinander in hierarchischen Beziehungen stehen und zu komplexen Strukturen werden. Die Gesetzmäßigkeiten, nach denen diese gebildet werden, beschreibt das grundlegende Konzept der Vererbung. Hier sind weiterhin die Begriffe Basisklasse und abgeleitete Klasse von Bedeutung, um die Verhältnisse der Klassen untereinander zu charakterisieren. Dabei beschreibt die Basisklasse allgemeine Eigenschaften, ist also eine Verallgemeinerung der abgeleiteten Klassen; diese sind somit Spezialisierungen der Basisklasse.

Beispiel: Basisklasse Kraftfahrzeug ist Verallgemeinerung der abgeleiteten Klassen (Spezialisierungen) Auto, LKW, Motorrad und Traktor.

Dabei erben die abgeleiteten Klassen alle Eigenschaften und Methoden der Basisklasse (d. h. ein Motorrad hat alle Eigenschaften eines Kraftfahrzeugs, und man kann alles mit ihm machen, das man mit einem Kraftfahrzeug machen kann). Zusätzlich führt die abgeleitete Klasse zusätzliche Eigenschaften und Methoden ein, die bei ihren Objekten möglich sind. (Das Motorrad hat z. B. einen Gepäckträger, ein Auto nicht, dafür aber einen Kofferraum.)

Programmierstil[Bearbeiten]

In vielen Programmiersprachen ist es üblich, dass der Name einer Klasse mit einem Großbuchstaben beginnt, Variablennamen dagegen mit einem Kleinbuchstaben.

Verbund[Bearbeiten]

Ähnlich der Klasse ist der Verbund ein Werkzeug zum Verwalten von zusammengehörigen Attributen. Er ist ein zusammengesetzter Datentyp aus verschiedenen anderer Datentypen. Die einzelnen Komponenten können als Attribute des neuen Verbundtyps betrachtet werden – in ihm sind jedoch keine Methoden beschrieben.

Beispiel[Bearbeiten]

Als Beispiel soll eine Lampe dienen. Eine Lampe kann verschiedene Eigenschaften (Attribute) besitzen, zum Beispiel Farbe, Gewicht und ob sie leuchtet. Da man mit den Eigenschaften Farbe und Größe wenig operieren kann, wäre eine sinnvolle Verhaltensweise demnach eine Lichtschalter-Methode, die den jeweiligen Zustand von an und aus bestimmt. Eine abstrakte Notation könnte so aussehen:

  class Lampe {
      // Eigenschaften
      gehaeusefarbe;      // Typ: { ZAHL, ZAHL, ZAHL }  für  { rot, grün, blau }
      gewicht;            // ZAHL
      lichtfarbe;         // Typ: { ZAHL, ZAHL, ZAHL }  für  { rot, grün, blau }
      helligkeit;         // ZAHL
 
      // Methoden
      einschalten();
      ausschalten();
  }

Konzepte wie die Vererbung ließen sich dadurch beschreiben, dass es verschiedene Arten von Lampen gibt, z. B. Straßenlampen, Taschenlampen oder Autoscheinwerfer. Diese speziellen Lampen wären dann Unterklassen der Klasse Lampe, d. h. sie würden erweiterte Attribute (z. B. Taschenlampe.maximaleLeuchtdauer, Autoscheinwerfer.Kippbarkeit) und Methoden (z. B. Taschenlampe.batterieLaden(), Autoscheinwerfer.fernlichtEinschalten()) besitzen. Für die speziellen Klassen ist die Lampenklasse eine Überklasse.

Programmbeispiel[Bearbeiten]

Coding-Beispiel in Python[Bearbeiten]

Das folgende Beispiel ist in der Programmiersprache Python geschrieben:


class Fahrzeug(object): 
    #Die Klasse "Fahrzeug" ist die Basisklasse.
 
    def bewegen(self):
        print "Fahrzeug wird bewegt."
    #end bewegen
#end class Fahrzeug
 
class Auto(Fahrzeug):
    #Die Klasse "Auto" ist die abgeleitete Klasse. 
 
    def bewegen(self):
        print "Auto wird bewegt."
    #end bewegen
#end class Auto
 
def fahren(fahrzeug):
    #zur Verdeutlichung der sog. "Polymorphie"
    fahrzeug.bewegen();
#end fahren
 
#--Hauptprogramm--
fahrzeug = Fahrzeug()
auto = Auto()
 
fahrzeug.bewegen()
auto.bewegen()
 
#Polymorphie: Methode 'fahren'
fahren(fahrzeug)
fahren(auto)
#--end Hauptprogramm--

Erklärung[Bearbeiten]

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

Die Basisklasse besitzt eine Methode namens bewegen(), die den Text „Fahrzeug wird bewegt.“ auf dem Computerbildschirm ausgibt. Die von Fahrzeug abgeleitete Klasse Auto hat ebenfalls eine Methode bewegen() und überschreibt die Methode von Fahrzeug. Die von ihr erzeugte Ausgabe lautet „Auto wird bewegt.“.

Anschließend folgt die Definition einer eigenständigen Funktion fahren(), 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 (fahrzeug), als auch der abgeleiteten Klasse (auto) erzeugt, und auf beide zuerst bewegen() aufruft und danach mit Hilfe von fahren() ebenfalls noch einmal bewegen() für beide Objekte ausführt.

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

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

Es ist zu erkennen, dass obwohl die Funktion fahren() für ein Fahrzeug definiert ist, sie auch für ein Auto funktioniert und die überschriebene Methode aufgerufen wird. D. h. sie funktioniert für Objekte der Basisklasse sowie für Objekte aller abgeleiteter Klassen (diese erben ja die Eigenschaften und „können“ somit auch alles, was die Basisklasse „kann“). Dieses (i. A. erwünschte) Verhalten nennt man Polymorphie.

Erweiterung[Bearbeiten]

Eine Erweiterung bzw. Abstraktion dieses Konzepts findet sich in dem Modell der abstrakten Klassen und der Metaklassen.

Möglich ist auch eine sogenannte anonyme Klasse. Dabei wird eine Klasse nur an genau der Stelle beschrieben, an der ein Objekt von ihr erzeugt wird; sie ist nicht getrennt (z. B. in einer eigenen Datei) als eigenständige Komponente im Quellcode beschrieben, und kann daher auch von anderen Programmteilen nicht wiederverwendet oder gezielt angesprochen werden. Die Klasse erhält auch keinen eigenen Namen. In der Regel erbt sie jedoch von einer anderen, diese beschreibt dann die Haupteigenschaften und -methoden des Objekts für seine spätere Verwendung. Die abgeleitete, namenlose Klasse modifiziert das Verhalten meist nur geringfügig.

Beispiel (Java):

  // Deklaration einer Variablen, um ein Objekt der Klasse "Button" aufzunehmen
  java.awt.Button hilfeButton;
 
  // Erzeugen eines Button-Objekts, speichern in hilfeButton
  hilfeButton = new java.awt.Button("Hilfe"); // "Hilfe" ist die Beschriftung des Buttons
  // Dem Button ein Objekt zuweisen, das eine Methode "actionPerformed" besitzt
  // (wird aufgerufen, wenn der Button angeklickt wird).
  hilfeButton.addActionListener( new java.awt.event.ActionListener() {
    void actionPerformed(ActionEvent e) 
    {
      System.out.println( "Hilfetext" );
    }
  } ); // end anonymous class

Es wird mit new ein Objekt erzeugt, das in Hauptsache einem java.awt.event.ActionListener entspricht (zwar keine Basisklasse, aber ein Interface). Als spezielle Verhaltensweise genau diesen Objekts wird die Methode actionPerformed so überschrieben, dass sie Hilfetext auf dem Bildschirm ausgibt. Da ein spezialisiertes Verhalten definiert wurde, ist das Objekt von einer abgeleiteten Klasse, also nicht von ActionListener direkt – es wurde aber kein Klassenname angegeben. Im nachfolgenden Programm kann das Objekt nur noch als ActionListener verwendet werden (Polymorphie).

Manche Programmiersprachen erlauben das Verändern von Klassen zur Laufzeit, sowie das nachträgliche Ändern der Struktur eines Objekts (hinzufügen/entfernen von Eigenschaften oder Methoden). Diese sogenannte „Reflexion“ sollte nur im Notfall verwendet werden, da das Programm dadurch sehr schwer verständlich wird.

Mitunter wird (ähnlich einer anonymen Klasse) auch eine innere Klasse definiert. Unterschied zu einer „normalen“ Klasse ist zunächst der Sichtbarkeitsbereich – eine innere Klasse ist innerhalb einer anderen („äußeren Klasse“) definiert. Ist sie privat, so können nur Objekte der äußeren Klasse Objekte der inneren erzeugen und verwenden. Ist die innere Klasse nicht-statisch, so ist eine Objekterzeugung sogar abhängig von einem Objekt der äußeren Klasse und nur über ein solches Objekt möglich.

Literatur[Bearbeiten]

  • Laura Lemay und Charles L. Perkins: Java in 21 Tagen, 2000, ISBN 3-8272-5578-3
  • Peter Pepper: Programmieren lernen – Eine grundlegende Einführung mit Java, Springer, 2007, ISBN 978-3-540-72363-9
  • Katharina Morik und Volker Klingspor: Informatik kompakt: Eine grundlegende Einführung mit Java, Springer, 2006, ISBN 3-540-24304-6

Weblinks[Bearbeiten]

 Wikibooks: Objektorientierte Programmierung (PHP) – Lern- und Lehrmaterialien

Anmerkungen[Bearbeiten]

  1. Zu Beginn der OOP wurde tatsächlich zu jedem Objekt auch jeweils ein Satz der Methoden vorgehalten, was zu sehr hohem Speicherverbrauch führte. Heute werden die Methoden nur noch 1* für alle Objekte dieser Klasse im Arbeitsspeicher gehalten; daher kann man sagen: „Die Klasse braucht (zur Laufzeit) so viel Speicherplatz wie die Klassenvariablen und der Platz für die Methoden.“