Das ATOS-Magazin 1/99
ATOS Programmierpraxis
Moderne Zeiten

# Von der Variablen zum Objekt

Die OT/OB-Lib wird - wie eingangs erwähnt - das Definieren neuer Variablentypen ermöglichen. Aber was heißt das eigentlich?

Etwas hochtrabend formuliert meint der Begriff der Variablen (oder der Veränderlichen) einen Ort, an dem zu verschiedenen Zeiten möglicherweise verschiedene Werte gemessen werden können. Diese Orte sind übrigens genau die passiven Komponenten, die im vorigen Kapitel angesprochen wurden. Orte, an denen sich der dort vorliegende Wert nicht ändern kann, heißen Konstanten.

Speicher

Wenn Sie in Ihrem Programm eine Variable anlegen, dann wird für diese Variable ein Stück des Hauptspeichers reserviert. An diesem "Ort" liegt dann der veränderliche Wert vor, den Sie über den Variablenbezeichner ansprechen und auslesen ("messen") können. In der Regel können Sie den Wert auch selbst beeinflussen, indem Sie der Variablen (also diesem Ort) einen neuen Wert zuweisen. Man sagt, bei dieser Anwendung liegt die Variable in einem Speicher.

Kanäle

Ferner gibt es noch solche Orte, die nicht zur Speicherung, sondern zur Übertragung (z.B. zur Wertübergabe an Unterprogramme) dienen. In diesem Fall spricht man davon, daß die Variable in einem Kanal liegt.

Variablentyp

Sie wissen, daß der Wert einer Variable immer in einem bestimmten Wertebereich liegen muß. Diesen Bereich nennt man nun Variablentyp. Genauergenommen nennt man einen Wertebereich eigentlich nur dann Variablentyp, wenn auch alle Elemente des Wertebereichs "vom gleichen Typ" sind. Auf den Begriff des Typs wird aber später noch einmal eingegangen.

Bsp.: Der Variablentyp `"WORD"` von GFA-Basic steht für den Wertebereich `"Ganze Zahl aus dem Intervall von -32768 bis 32767"`.

Im Folgenden werden nun auf dieser Grundlage die Begriffe "Objekt", sowie "konkretes" bzw. "abstraktes Attribut" eingeführt.

Mit der OT/OB-Lib sollen nämlich nun nicht nur neue Variablentypen (und damit neue Wertebereiche) definiert werden. Der eigentliche Einsatz der OT/OB-Lib soll darüber hinausgehen. Während eine Variable eigentlich nur genau einen Wert aus ihrem Wertebereich annehmen kann, und derjenige, der Zugriff auf die Variable hat, ihren Wert auslesen und vielleicht auch setzen kann, sollen die Variablen, die mit der OT/OB-Lib erschaffen werden, mit einem eingeschränkten Zugriff versehen werden. Wer Zugriff darauf hat, soll nicht den kompletten Wert sehen (oder verändern dürfen), sondern nur Zugriff haben auf die für die Benutzung wesentlichen Teile. Daß eine solche Einschränkung in Wahrheit ein Fortschritt ist, soll im Folgenden erläutert werden.

Die Konzentration richtet sich zunächst auf den einfachen Variablentyp `WORD` und wir betrachten, welche grundlegenden Operationen für Variablen diesen Typs zur Verfügung stehen:

- Variablenspeicher anlegen
- Variablenwert setzen
- Variablenwert auslesen
- Variablenspeicher freigeben

Als Beispiel diene nun ein Programm, das noch zu langsam ausgeführt wird und zeitoptimiert werden muß. Zu Test- und Meßzwecken soll daher eine `WORD`-Variable so präpariert werden, daß jederzeit ermittelt werden kann, wie oft auf sie zugegriffen wurde. So kann man später herausfinden, ob auf die Variable besonders oft zugegriffen wurde und ob sich daher vielleicht Optimierungen lohnen könnten.

Mit einer solchen, neuen `WORD`-Variablen kann man nun mehr tun als mit einer normalen `WORD`-Variablen:

- Variablenspeicher anlegen (und Zugriffszähler auf den Wert `0` setzen)
- Variablenwert setzen (und Zugriffszähler erhöhen)
- Variablenwert auslesen (und Zugriffszähler erhöhen)
- Zugriffszähler auslesen
- Variablenspeicher freigeben

Der Wert einer solchen Variablen besteht offenbar aus zwei Teilwerten, nämlich dem Wert der `WORD`-Variablen und dem Wert des Zugriffszählers.

Modularität

Zunächst wird noch der Begriff der Modularität benötigt. Damit ist gemeint, einzelne Komponenten des Systems lediglich nach außen hin zu spezifizieren und demjenigen, der die Komponente realisiert, jede Freiheit bei der Wahl der Mittel zu lassen. Einzige Bedingung für ihn ist also, daß die Komponente später in dem Rahmen funktioniert, in dem man sie zuvor spezifiziert hatte. Dadurch kann die Komponente für sich betrachtet werden, und umgekehrt kann das System für sich betrachtet werden, ohne den genauen Aufbau der Komponente berücksichtigen zu müssen.

Dieser Gedanke soll auf das Beispiel übertragen werden. Es wird die Komponente "WORD-mit-Zugriffszähler" so spezifiziert, daß nur festgelegt wird, wie sie sich nach außen verhält. Mit der sehr knappen Beschreibung von eben wurde das schon erledigt. Alle für die Benutzung der Variablen dieses Typs wesentlichen Dinge wurden genannt. Nun liegt es am Konstrukteur, eine Komponente so zu bauen, daß sie diese Eigenschaften hat. Wie der Konstrukteur der Komponente konkret dafür sorgt, daß Zugriffszähler und Variablenwert richtig verwaltet werden, bleibt ihm also überlassen. Das einzige, was man im voraus sagen kann, ist, daß er seinerseits Speicher irgendeiner Art innerhalb der Komponente benötigen wird, denn sonst könnte sich die von ihm entworfene Komponente die Werte des Zählers und der eigentlichen Variablen nicht merken. Der konkrete Aufbau bleibt aber seine Sache.

Die Attribute

Die nach außen hin "sichtbaren" Variablen dieser Komponente nennt man nun abstrakte Attribute. Die Speichervariablen, die der Konstrukteur aber in der Komponente tatsächlich angebracht hat, nennt man konkrete Attribute.

Mit der Bezeichnung "abstrakt" wird hier angedeutet, was realisiert wurde, mit der Bezeichnung "konkret" wird angedeutet, wie es realisiert wurde.

Damit wurde der Zugriff auf die Variable - wie oben angedeutet - eingeschränkt. Von außen kommt man nicht an die konkreten Attribute heran. Lediglich das für die Benutzung Wesentliche, die abstrakten Attribute, sind erreichbar. Der Vorteil liegt auf der Hand. Wenn man sich aus irgendeinem Grund dafür entscheiden muß, die Komponente auf eine andere Weise zu realisieren, kann der Rest des Systems unangetastet bleiben.

Die Begriffe sollen anhand einer Realisierung einer Variablen des Typs "`WORD-mit-Zugriffszähler`" in GFA-Basic noch einmal verdeutlicht werden:

    PROCEDURE myword_create
      LET myword_value&=0
      LET myword_counter&=0
    RETURN
    PROCEDURE myword_set(new_value&)
      INC myword_counter&
      LET myword_value&=new_value&
    RETURN
    FUNCTION myword_get
      INC myword_counter&
      RETURN myword_value&
    ENDFUNC
    FUNCTION myword_counter
      RETURN myword_counter&
    ENDFUNC
    PROCEDURE myword_delete
      ' Hier nur ein Dummy
    RETURN

Die konkreten Attribute sind hier die beiden globalen `WORD`-Variablen `myword_value&` und `myword_counter&`. Sie dürfen von außen nicht benutzt werden. Stattdessen darf man nur über die abstrakten Attribute, nämlich die Prozeduren und Funktionen `myword_create`, `myword_set`, `myword_get`, `myword_counter` und `myword_delete` auf die "Variable" zugreifen.

So kann jederzeit an der Komponente "`myword`" gebastelt werden, ohne daß an den Stellen, an denen die Komponente benutzt wird, ebenfalls Änderungen gemacht werden müssen.

Warum aber spricht man nun von Attributen statt von Variablen?

Der Objektbegriff

Seit geraumer Zeit versucht man die Erkenntnisse der Philosophie über das menschliche Denken auch beim Programmieren anzuwenden. Die Philosophie lehrt nun, daß der Mensch seine Welt als eine Struktur aus einzelnen konkreten Objekten erfährt. Diese Objekte sind Gegenstände oder Prozesse (abgeschlossene Vorgänge) mit meßbaren Eigenschaften. Diese Eigenschaften werden üblicherweise als Attribute bezeichnet (Nur der Vollständigkeit halber sei angemerkt, daß zu diesen Attributen auch die über ein Objekt entscheidbaren Dinge, die sich durch die Struktur, in die es eingebettet ist, ergeben, mit einbezogen werden.).

Man sieht nun auch eine Variable als ein konkretes Objekt an, von dem man eine Eigenschaft messen, also ein Attribut ermitteln kann. Das Auslesen des Variablenwertes wird also als Messen eines Attributes dieses Objektes angesehen. Verbundvariablen (also Variablen, die sich aus mehreren Teilvariablen zusammensetzen) rechtfertigen diese Bezeichnung schon eher. Man liest ja fast nie den Wert einer Verbundvariablen aus, als viel öfter den Wert einer ihrer Teilvariablen. Eine Variable hat aber genau einen Wert. Wenn nun auch ein Teil von diesem Wert abgelesen werden kann, ist es im eigentlichen Sinne keine Variable mehr. Im Beispiel von oben war die Word-"Variable" sogar in der Lage, einen Zugriffszähler zu verwalten. In diesem Fall paßt der Begriff der Variablen also definitiv nicht mehr, denn eine Variable ist ein Ort, und ein Ort kann natürlich nichts tun, also auch keinen Zähler verwalten.

Daher spricht man allgemein von Objekten mit Attributen und zugehörigen Werten statt von Variablen mit zugehörigem Wert. Besser und verständlicher eignen sich wohl analog dazu die Begriffe "Komponente" und "Schnittstelle" (anstatt "Objekt" und "Attribut"), womit man dann sofort auch einen Aufbau verbindet und sich den Systemaufbau mit einem Schaltplan verständlich machen kann. Später wird noch genauer erklärt, was unter einem Objekt im Sinne des Programmierers zu verstehen ist. Zunächst soll dieser Einblick genügen. Es bleibt nämlich noch die Frage offen, was sich hinter der Idee des objektorientierten Programmierens versteckt.

Die Idee des objektorientierten Programmierens