Klasse (OOP)

aus GlossarWiki, der Glossar-Datenbank der Fachhochschule Augsburg

Definition (von W. Kowarschick)[1]

Eine Klasse dient (im Sinne des objektorienten Paradigmas) dazu, die Schnittstellen und evtl. auch eine oder gar mehrere Implementierungen von „gleichartigen“ Objekten ganz oder zumindest teilweise festzulegen.

Eine Klasse besteht aus folgenden Teilen:

  • einer Klassenextension: Die Klassenextension enthält zu jedem Zeitpunkt alle Objekte, die der Klasse zugeordnet sind.
  • beliebig vielen (0, 1, 2, ...) Klassenimplementierungen: Diese implementieren die im Klassenschema deklarierten Methoden teilweise oder vollständig und garantieren dabei die stete Erfüllung aller im Klassenschema definierten Integritätsbedingungen. Unterschiedliche Implementierungen können sich in Hinblick auf Performanz-Aspekte unterscheiden.
  • den Klassenmethoden (statische Methoden): Eine Klasse verhält sich wie ein spezielles Objekt) und kann daher eigene (Klassen-)Methoden und (Klassen-)Attribute enthalten. Überlicherweise gibt es zumindest Methoden zur Verwaltung der Klassenextension, d.h. zum Erzeugen (Konstruktoren) und evtl. auch zum Zerstören (Destruktoren) von zugeordneten Objekten.

Abstrakte Klasse

Eine Klasse, für es Klassenimplementierungen gibt, die die im Klassenschema definierten Methoden nicht vollständig implementieren, heisst abstrakte Klasse.

Schnittstelle (Interface)

Eine Klasse, für die es keine Klassenimplementierung gibt, heißt Schnittstelle oder Interface.

Singleton-Klasse

Eine Klasse, deren Extension genau ein Objekt enthält, heißt Singleton-Klasse oder kurz Singleton.

Subklasse

Eine Klasse B heißt Subklasse der Klasse A, wenn die Extension von B eine Teilmenge der Extension von A ist und wenn die Integritätsbedingungen der Klasse A logisch aus den Integritätsbedingungen der Klasse B folgen:

Integritätsbedingungen(B) ⇒ Integritätsbedingungen(A)

Das heißt, jedes Objekt aus der Extension von B liegt nicht nur auch in der Extension von A, sondern erfüllt auch alle Integritätsbedingungen von A.

Siehe auch: Vererbung (OOP)

Bemerkungen

Klassenextension

Die meisten objektorientierten Programmiersprachen verwalten die Klassenextension nur intern. Das heißt, ein Programmierer kann nicht direkt darauf zugreifen. Es ist allerdings problemlos möglich, die Verwaltung einer Klassenextension mit Hilfe von Klassenzustandsvariablen und -methoden zu realisieren.

Objektorientierte Datenbanksysteme machen die Klassenextension dagegen immer allen Benutzern zugänglich, die die entsprechenden Rechte haben. In derartigen Systemen wird an Stelle des Begriffs Klassenextension üblicherweise der Begriff Tabelle verwendet. Die dauerhafte Speicherung von Daten in Tabellen ist die wesentliche Aufgabe eines jeden Datenbanksystems.

Klassenschema

Ein Klassenschema ist laut Definition nichts weiter, als eine Menge von Integritätsbedingungen, die jedes Objekt erfüllen muss, dass der zugehörigen Klasse angehört.

Eine Methoden-Signatur ist eine spezielle Integritätsbedingung, bestehend aus Zugriffsbeschränkungen (public, private, protected, internal etc.), Methodennamen, Eingabeparametern samt zugehörigen Datentypen sowie den Datentypen der Methodenergebnisse.

Das Vorhandensein einer Methoden-Signatur in einem Klassenschema definiert eine Invariante: Eine Methode, die dieser Signatur genügt, muss dauerhaft zur Kommunikation mit den Objekten der Klasse, die gemäß der Zugriffsbeschränkung Zugriff haben, zur Verfügung stehen.

Außerdem definiert jede Signatur eine Vorbedingung (zum Zeitpunkt des Methodenaufrufes müssen die Argumente den Bedingungen genügen, die in der Signatur an die Eingabeparameter gestellt werden) und eine Nachbedingung (die Methodernergebnisse genügen den in der Signatur geforderten Ergebnisdatentypen).

Beispiel

public class Person
{
  private var v_birthday: Date;
   
  // Method "age"
  public function age(p_date: Date = null): int
  {
    if (p_date == null) 
      p_date = new Date();

    return (    (v_birthday.month > p_date.month)
            || ((v_birthday.month = p_date.month) &&
                (v_birthday.date  > p_date.date)
               )
           )
           ? p_date.fullYear - v_birthday.fullYear - 1
           : p_date.fullYear - v_birthday.fullYear
  }
    
  // Constructor
  public function Person(p_birthday: Date)
  {
    v_birthday = p_birthday;
  }
}

Jedes Personenobjekt, d.h. jedes Element der Extension der Klasse Person stellt eine Methode age zur Verfügung, 

public function age(p_date: Date = null): int

auf die jedes (public) andere Objekt zugreifen darf: 

var wolfgang: Person = new Person(new Date(1961, 5, 5));
      
trace(wolfgang.age());
trace(wolfgang.age(new Date(2011,5,2)));
trace(wolfgang.age(new Date(2011,5,11)));
trace(wolfgang.age('2011-05-11'));  // Fehler (zur Compilezeit), 
                                    // da die Vorbedingung 
                                    // „das Argument ist vom Typ Date“
                                    // nicht erfüllt ist.

Der Eingabeparameter muss nicht angegeben werden (Defaultwert null), aber falls er angegeben wird, muss er vom Typ Date sein (Vorbedingung). Die Methode age liefert eine Integerzahl zurück (Nachbedingung).

Dass age (als Nachbedingung!) das Alter der aktuellen Person zu einem bestimmten Datum bzw. zum aktuellen Datum (falls p_date == null) ermittelt, lässt sich der Signatur dagegen nicht entnehmen. Hierfür wäre die Angabe von weiteren Integritätsbedingungen notwendig, was aber nur von wenigen Sprachen, wie z.B. Eiffel, unterstützt wird. Eine weitere (deutlich schwächere) Nachbedingung wäre z.B., dass das Resultat positiv sein muss, wenn das übergebene Datum p_date größer ist, als das Geburtsdatum. Diese Bedingung wird z.B. verletzt, wenn p_date so groß gewählt wird, dass das Alter größer ist als die größte darstellbare Integerzahl. Um gerade vor solchen Überraschungen gefeit zu sein, ist der Einsatz von Integritätsüberprüfungen, die über die Angabe von Signatur-Informationen hinaus gehen, sehr empfehlenswert.

Bislang wurde gezeigt, dass die Signatur der Methode age eine Vor- und eine Nachbedingung formuliert. Sie formuliert allerdings auch eine Invariante: Die Methode age existiert dauerhaft, d.h. sie kann nicht entfernt oder verändert werden: 

wolfgang.age = null; // Fehler (zur Compilezeit)

Dies ist nicht so selbstverständlich, wie es zunächst scheint. Wäre (in ActionScript) die Klasse Person als dynamisch deklariert worden 

public dynamic class Person
{
  ...
}

so könnten jedem Personenobjekt jederzeit neue Methoden zugefügt werden. Und diese können auch wieder entfernt werden: 

wolfgang.ageChristmas2011 = function (): int { return wolfgang.age(new Date(2011,12,24)); };

trace(wolfgang.ageChristmas2011());

wolfgang.age = null;                // immer noch ein Fehler (zur Compilezeit)
wolfgang.ageChristmas2011 = null;   // kein Fehler

trace(wolfgang.ageChristmas2011()); // jetzt ein Fehler (zur Laufzeit), ageChristmas2011 existiert nicht mehr

Metaklassen

Eine Klasse, die dazu dient andere Klassen zu definieren, wird Metaklasse genannt. Eine Klasse, die dazu dient Metaklassen zu definieren, heißt entsprechend Metametaklasse. Und so weiter. Die meisten objektorientierten Systeme unterstützen jedoch keine Metaklassen. In diesen Systemen wird eine Klasse als ein spezielles Objekt aufgefasst, das direkt, d.h. ohne Zuhilfenahme einer anderen Klasse, definiert werden muss. Dies stellt jedoch keinen Widerspruch zum hier verwendeten Objektbegriff dar (siehe dort insb. den Abschnitt „Klassen“).

Quellen

Siehe auch

Wikipedia: Klasse (objektorientierte Programmierung)


Dieser Artikel ist GlossarWiki-konform.
  1. ↑ Kowarschick, W.: Multimedia-Programmierung
Abgerufen von „https://glossar.hs-augsburg.de/w/index.php?title=Klasse_(OOP)&oldid=15907“