Objektorientierte Programmiersprachen am Beispiel Eiffel - Software ...

Objektorientierte
Programmiersprachen
am Beispiel Eiffel
Referat im Rahmen des Seminars
„Programmiersprachen“
24. Mai 2004
Jan Griesel
Prof. Dr. Claudia Leopold, Dipl.-Inf. Michael Süß
Fachgruppe Programmiersprachen/ -methodik
Fachbereich Elektrotechnik / Informatik
Universität Kassel

Objektorientierte Programmiersprachen am Beispiel Eiffel - 1 -
Inhalt
Inhalt ..............................................................................................1
1. Einführung Eiffel .......................................................................2
2. Objektorientierte Programmierung..............................................3
2.1 Einführung ............................................................................3
2.2 Klassen und Objekte ..............................................................3
2.3 Typen und Verweise ...............................................................4
2.4 Generalisierung, Vererbung.....................................................5
2.5 Datenkapselung.....................................................................5
2.6 Redefinition...........................................................................7
2.7 Polymorphismus, dynamisches Binden......................................8
2.8 Abstrakte Klassen ..................................................................9
2.9 Parametrisierbare Klassen.......................................................9
2.10 Multiple Vererbung ............................................................ 10
2.11 Wiederholtes Erben ........................................................... 10
2.12 Zusicherung, Design-by-Contract ........................................ 11
3.
4.
5.
6.
Weitere Besonderheiten........................................................... 12
Eiffel
Einsatzgebiete........................................................................ 12
Fazit ..................................................................................... 12
Literatur ................................................................................ 13

Objektorientierte Programmiersprachen am Beispiel Eiffel - 2 -
1. Einführung Eiffel
Eiffel ist eine reine objektorientierte Programmiersprache, welche seit
1985 von dem französischen Informatiker Bertrand Meyer und seiner
Firma Interactive Software Engeneering Inc. (Goleta, Kalifornien) als
Alternative zu C++ entworfen wurde. Seinen Namen verdankt Eiffel dem
in der zweiten Hälfte des 19. Jahrhunderts bekannt gewordenen Ingenieur
Gustave Eiffel, Erbauer des Eiffelturms (erbaut 1887-1889) in Paris. Der
Name Eiffel stellt den Anspruch in den Vordergrund, eine Sprache zu
geschaffen, mit der Softwareentwicklung gemäß den Standards des
Ingenieurwesens ermöglicht wird.
Bei Eiffel handelt es sich im Unterschied zu C++ um einen vollständig
neuen Entwurf, der lediglich in Anlehnung an ältere Sprachen (Ada 1 und
der ALGOL-Sprachfamilie 2 ) aufgebaut wurde.
Ziel der Entwicklung von Eiffel ist es, eine Sprache zu erschaffen, mit der
es möglich ist umfangreiche Softwareprojekte aus zuverlässigen, wieder
verwendbaren und leicht wartbaren Modulen zu konstruieren. Um dies zu
erreichen, wurden riskante Möglichkeiten, wie manuelle
Speicherverwaltung, globale Variablen, GOTOs, etc. komplett
ausgeschlossen.
Besonderheiten von Eiffel sind u.a. Zusicherung (Desing-by-Contract) und
Multiple Vererbung.
Die Sprachdefinition von Eiffel ist Public-Domain und steht unter der
Kontrolle von Nonprofit International Consortium for Eiffel (NICE) 3 ,
welches sich das Recht vorbehält, jedes Entwicklerwerkzeug bezüglich der
Konformität zum Standard zu validieren.
Es existieren wenige kommerzielle Eiffel-Entwicklungsumgebungen und
mit SmartEiffel 4 zumindest ein OpenSource-Compiler. Die Sprache konnte
bisher nicht an den Verbreitungsgrad von Java oder C++ heranreichen.
Eiffel besitzt keine größere Software- oder IT-Firma, von welches es
unterstützt wird, wie z.B. Java durch Sun.
Eiffel
1
Ada ist eine strukturierte Programmiersprache mit statischer Typenbindung. Sie
wurde in den 1970er Jahren von Jean Ichbiah entworfen.
2
ALGOL wurde von 1958-1963 entwickelt und diente zur Lösung
wissenschaftlich-numerischer Probleme.
3 NICE http://eiffel-nice.org
4 Eiffel Compiler unter GNU http://smarteiffel.loria.fr

Objektorientierte Programmiersprachen am Beispiel Eiffel - 3 -
2. Objektorientierte Programmierung
Dieser Themenbereich ist in mehrere Unterpunkte gegliedert, welche in
sich wiederum in der folgenden Art untergliedert wurden. Zuerst erfolgt
eine kurze allgemeine Definition zu dem Themenkomplex, darauf wird die
Umsetzung in der Programmiersprache Eiffel erläutert und schließlich
werden die Unterschiede zur Umsetzung in der Programmiersprache Java
aufgelistet.
2.1 Einführung
Die Idee der Objektorientierung ist fast 30 Jahre alt. In den 90er Jahren
war die objektorientierte Programmierung (Abkürzung OOP) das führende
Programmierparadigma. Viele der heute verwendeten
Programmiersprachen sind entweder von Grund auf objektorientiert (wie
Eiffel, Java, SmallTalk) oder wurden im Laufe der Zeit mit
objektorientierten Erweiterungen versehen (Basic, Pascal, ADA).
2.2 Klassen und Objekte
Bei der objektorientierten Programmierung werden Daten und die auf
diese Daten anzuwendenden Operationen als Klassen zusammengefasst.
Ein Objekt ist ein Exemplar (auch Instanz genannt) einer Klasse, es
enthält durch Attribute repräsentierte Informationen, deren Struktur in
der Klasse definiert ist. Im Programmablauf kommunizieren die Objekte
miteinander, indem ein Objekt die Attribute eines anderen Objektes auf
bestimmte Eigenschaften hin abfragt oder es beauftragt, eine bestimmte
Operation mit einem bestimmten Datenwert auszuführen.
In Eiffel besteht ein Programm nur aus Klassen. Zur Laufzeit werden
Exemplare der Klassen, die Objekte, erzeugt.
class NAME
Eiffel
end – class NAME
creation
...
feature
...

Objektorientierte Programmiersprachen am Beispiel Eiffel - 4 -
Die Eigenschaften von Objekten werden durch Attribute angegeben. Das
Verhalten von Objekten wird durch Methoden definiert. Attribute und
Methoden werden im Abschnitt features definiert.
Der Bereich creation ist optional. In ihm werden Methoden, aus dem
Bereich feature aufgelistet, welche zu Initialisierung eines Objektes
wichtig sind.
In Eiffel werden Klassen meist erstellt, um einen abstrakten Datentyp zu
beschreiben. Ein abstrakter Datentyp stellt Schnittstellen zur Verfügung,
welche bestimmte Aufgaben erfüllen. Es ist jedoch nicht bekannt, wie
diese Aufgaben erfüllt werden. Detaillierter wird auf diesen Punkt im
Bereich Datenkapselung 2.5 eingegangen.
Ein Unterschied zu diesem Punkt zur ebenfalls objektorientierten
Programmiersprache Java ist der, dass Attribute und Methoden nicht, wie
in Eiffel, zu features zusammengefasst werden. Ein Java Programm
benötigt eine Klasse, welche als Hauptprogramm-Klassen fungiert, mit
einer main-Methode. Bei Eiffel wird dies durch die (hier) root-Klasse
genannte Klasse erledigt, diese enthält im Abschnitt creation eine
bestimmt Prozedur.
2.3 Typen und Verweise
Ein Typ spezifiziert das Verhalten einer Menge von Objekten.
In objektorientierten Sprachen muss grundsätzlich unterschieden werden
zwischen dem statischen Typ (bzw. der statischen Klasse) eines Objektes,
womit der Typ gemeint ist, den der Compiler herleiten kann, und dem
dynamischen Typ (bzw. der dynamischen Klasse), welcher den Typ des
Objektes zur Laufzeit eines Programms tatsächlich besitzt.
Eiffel ist eine statisch getypte Sprache. Dies bedeutet, dass jedes feature
einer Klasse mit einem eindeutigen Datentyp deklariert werden muss.
class REFERAT
feature
autor: PERSON;
titel: STRING;
seitenzahl: INTEGER;
end – class REFERAT
Die Attribute titel und seitenzahl werden mit den vordefinierten
Eiffel
Datentypen STRING und INTEGER definiert. Das Attribut autor hat als
Datentyp die Klasse Person. Diese Deklaration bedeutet, dass die zum
Attribut autor gehörende Komponente eines Referatobjektes ein Verweis
auf ein Objekt vom Typ PERSON ist.
Es gibt in Eiffel nur zwei Arten von Datentypen: einfache Typen (INTEGER,
BOOLEAN, CHARACTER, REAL und DOUBLE) und Klassentypen.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 5 -
Klassentypen müssen durch Klassendeklarationen definiert werden und
gehören nicht zum Basistypsystem von Eiffel.
2.4 Generalisierung, Vererbung
Bei der Generalisierung werden Eigenschaften hierarchisch gegliedert,
wobei Eigenschaften mit allgemeinerer Bedeutung (allgemeineren)
Oberklassen zugeordnet und speziellere Eigenschaften solchen Klassen
zugeordnet werden, welche den Oberklassen untergeordnet sind. Die
Eigenschaften der Oberklassen werden an die Unterklassen weitergegeben
oder vererbt. Die Unterklasse verfügt somit über ihre spezifizierten
Eigenschaften als auch den Eigenschaften ihrer Oberklasse(n).
Eine Vererbung von einer Oberklasse an mehrere Unterklassen ist
möglich, ein gleichzeitiges erben von mehreren Oberklassen fällt in den
Bereich Multiple Vererbung 2.10.
Die Grafik zeigt eine Klassenhierarchie, wobei die Klasse Oberklasse eine
Generalisierung der Klasse Ober-Oberklasse darstellt und selbst von den
Klassen Unterklasse 1 und Unterklasse 2 geerbt wird.
Generalisierung wird in Eiffel so umgesetzt, dass zu Beginn der Definition
einer Klasse in einer Erbklausel die jenige Klasse angegeben wird, von
welcher Eigenschaften geerbt werden sollen. Die Eigenschaften (features)
der Oberklasse müssen nicht erneut im feature-Bereich genannt werden,
da sie automatisch verfügbar sind. Lediglich die Eigenschaften die neu
hinzukommen müssen im feature-Bereich explizit benannt werden.
Eiffel
In Java ist dieser Vorgang bis auf eine andere Form der Notation gleich.
2.5 Datenkapselung
Unter Kapselung versteht man selbstständige Programmmodule, die
sowohl Daten (Attribute) als auch deren Verarbeitungsroutinen

Objektorientierte Programmiersprachen am Beispiel Eiffel - 6 -
(Methoden) enthalten. Die Datenstruktur eines gekapselten Objektes
bleibt verborgen. Zugriff auf das Objekt kann nur über öffentlich sichtbare
Attribute oder Methoden genommen werden.
Datenkapselung ist besonders im Zusammenhang mit Generalisierung
oder Vererbung besonders wichtig. Ziel ist es nur die Informationen zur
Verfügung zu stellen, welche für die Funktion einer Unterklasse dringend
nötig sind.
Eiffel bietet hierbei besondere Möglichkeiten, die es in Java in dieser Art
nicht gibt. So ist es in Eiffel möglich nur bestimmte geerbte Eigenschaften
an eine weitere Unterklasse zu exportieren. Hierfür gibt es direkt unter der
Erbklausel einen export-Bereich, in welchem jene Eigenschaften der
Oberklasse einzeln benannt werden, welche zusammen mit den neuen
Eigenschaften in der Unterklasse verfügbar sein sollen. Ist dieser Bereich
nicht vorhanden, so sind alle Eigenschaften in der Unterklasse verfügbar.
Diese Methode der Zugriffsbeschränkung auf Eigenschaften der
Oberklasse durch Unterklassen wurde während der Entwicklung von Eiffel
noch weiter verfeinert. So ist es nun sogar möglich explizit zu den
Eigenschaften, welche exportiert werden sollen, auch eine Unterklasse
anzugeben, an welche die Eigenschaften vererbt werden sollen. Statt
hierbei alle zu vererbenden Eigenschaften einzeln aufzuzählen, kann auch
ein Schlüsselwort (all) angegeben werden, so dass alle Eigenschaften
vererbt werden. Ist bei dieser Exportmethode eine Unterklasse nicht
genannt, so werden keine Eigenschaften der Oberklasse an diese vererbt,
außer den neuen Eigenschaften der vererbenden Klasse selbst. Ist eine
Eigenschaft für eine Unterklasse freigegeben, so steht sie auch
automatisch allen Unterklassen dieser Unterklasse zur Verfügung, sofern
der Export nicht in einer anderen Unterklasse eingeschränkt wird.
In Java wird eine Zugriffskontrolle realisiert, indem jedes Attribut und jede
Methode mittels der Angaben public, private, protected und package bei
der Initialisierung klassifiziert wird. Die einzelnen Angaben Regeln wir
folgt:
- public: Auf Komponenten mit diesem Zugriffsrecht kann man
überall dort zugegriffen, wo man auf die Klasse zugreifen kann, in
der sie definiert sind.
- private: Auf private Komponenten kann man nur innerhalb der
Klasse zugreifen, in der sie definiert sind.
- protected: Auf Komponenten mit diesem Zugriffsrecht kann man
innerhalb des Paketes (package), das die Klasse enthält, in der
sie definiert sind, und in Unterklassen, zugreifen.
- package: Auf Komponenten ohne ein Zugriffsrecht-Attribut kann
man innerhalb des Paketes, das die Klasse enthält, in der sie
definiert sind, zugreifen.
Eiffel
und Methoden keine explizite Nennung von Erben geben. Stattdessen
Wie man deutlich erkennen kann ist der Ansatz der Zugriffssteuerung in
Java im Vergleich zu Eiffel eher indirekt. Es kann oder muss für Attribute

Objektorientierte Programmiersprachen am Beispiel Eiffel - 7 -
werden durch die Vergabe der Zugriffsrecht-Attribute Gruppen definiert,
welche Zugriff auf eine bestimmte Eigenschaft haben.
2.6 Redefinition
Unter Redefinition versteht man die Veränderung der Implementierung
geerbter Eigenschaften. So können geerbte Methoden überschrieben
werden, sofern man die Berechtigung dazu hat.
Um den Sinn dieser Möglichkeit besser zu verdeutlichen, dient dieses
Beispiel. Nehmen wir an in einer Firmenfinanzsoftware existiert eine
Klasse Mitarbeiter, welche u.a. das Gehalt eines Mitarbeiters zur
Verfügung stellen kann. Durch die Schaffung eines neuen Arbeitsbereiches
in der Firma kommt es zu Neueinstellungen besonderer Angestellter,
welche nach Leistung vergütet werden sollen. Dazu wird eine neue Klasse
Leistungsmitarbeiter erstellt, welche eine Unterklasse der Klasse
Mitarbeiter ist. In dieser Unterklasse wird nun die Methode, welche das
Gehalt der Mitarbeiter errechnet durch eine neu Methode, welche auf
einem anderen Rechenschlüssel basiert, ersetzt.
Eiffel ermöglicht es geerbte Eigenschaften neu zu definieren. Hierzu wird
in dem redefine-Bereich angegeben, welche der geerbten Eigenschaften
(features) verändert werden. Jedes dieser features muss nun erneut als
feature der Klasse im eigenen feature-Bereich deklariert und später
implementiert werden.
class LEISTUNGSMITARTBEITER
inherit MITARBEITER
redefine
gehalt
export
{ARBEITGEBER} name, vorname, adresse;
{FINANZAMT} all
end
feature
abteilung: STRING;
raum, telefon: INTEGER;
gehalt: REAL is -- Gehalt berechnen
do Result := Gehalt nach Leistung
end
end -- class LEISTUNGSMITARTBEITER
Eiffel
Die dargestellte Vererbung mit Redefinition zeigt eine Deklaration der
Klasse aller Leistungsmitarbeiter, in der das feature gehalt neu definiert
wurde. Ohne den redefine-Bereich wäre die erneute Deklaration von
gehalt als Merkmal von Leistungsmitarbeiter ein Fehler, da gehalt
bereits aus der Klasse Mitarbeiter übernommen wird.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 8 -
Der redefine-Bereich teilt mit, welche features einer Oberklasse in einer
Unterklasse neu definiert werden. Hierdurch wird gewährleistet, dass der
selbe Name sich auf verschiedene aktuelle features beziehen kann.
Abhängig vom Typ des Objektes, auf das es angewandt wird, erhält man
eine andere Implementierung.
Es ist nicht möglich ein feature beliebig abzuändern. Von außen betrachtet
muss ein feature im Wesentlichen unverändert, d.h. auf die gleiche Art
aufrufbar und veränderbar, bleiben. Die Vereinbarungen der Oberklasse
müssen weiterhin Gültigkeit haben.
Zu den Vereinbarungen, die von der Oberklasse übernommen werden
müssen, gehören insbesondere die Anzahl der Argumente und die Typen
der features. Routinen müssen Routinen bleiben und Attribute Attribute.
In Java ist eine Redefinierung durch eine Unterklasse ebenfalls möglich.
Attribute und Methoden dürfen sogar umdefiniert und überladen (siehe
Abschnitt 2.7) werden, sofern die Zugriffsrechte dies zulassen. Mit dem
Attribut final kann man verhindern, dass eine Methode in Unterklassen
verändert wird. Dies schließt aber nicht aus, dass sie in der Unterklasse
noch benutzt werden kann. Auch Attribute können mit final deklariert
werden. Ein derartiges Attribut erhält genau einmal einen Wert, und zwar
durch die Initialisierung.
2.7 Polymorphismus, dynamisches Binden
Polymorphismus (Vielgestaltheit) bezeichnet im Allgemeinen die Fähigkeit,
verschiedene Formen anzunehmen. Bezogen auf die Objektorientierung
bedeutet Polymorphie und dynamisches Binden, dass in einer
Klassenhierarchie gleichnamige Operationen für verschiedene
Unterklassen unterschiedlich implementiert sein können. Objekte können
polymorph sein, d.h. die zum jeweiligen Kontext passende Operation zur
Verfügung stellen. Wenn für ein einzelnes Objekt die spezifisch
anwendbare Operation erst zu Laufzeit ausgewählt wird, spricht man von
Operationen, welche dynamisch zu den Objekten gebunden werden.
Eiffel bietet Polymorphismus durch die Möglichkeit, Eigenschaften von
Klassen teilweise oder auch ganz zu redefinieren. Durch dynamisches
Binden wird dann zur Laufzeit ermittelt, welche der redefinierten
Versionen (d.h. welche konkrete Implementierung) tatsächlich ausgeführt
werden soll. Eine Zuweisung der Form a := b ist in Eiffel zulässig, nicht
nur wenn a und b vom selben Typ sind, sondern auch, wenn b Instanz
einer Unterklasse der Klasse von a ist.
Eiffel
gleichen Namen, können sich aber z.B. in der Art der Übergabewerte
Java bietet ebenfalls Polymorphismus, hier jedoch durch überladen von
Methoden. Das Überladen ist im Grunde eine Redefinierung einer geerbten
Methode mit dem Unterschied, dass mehrere Versionen der redefinierten
Methode in einer Klasse vorkommen können. Alle Versionen haben den

Objektorientierte Programmiersprachen am Beispiel Eiffel - 9 -
unterscheiden. Es bleibt dem Compiler überlassen, die richtige Version für
eine bestimmte Gelegenheit auszuwählen.
2.8 Abstrakte Klassen
Die Methoden in einer abstrakten Klasse sind nur durch die Definition der
Vor- und Nachbedingung definiert. Die Methoden wurden ohne eigentliche
Operation implementiert. Diese wird in einer abgeleiteten Klasse
implementiert, die Implementierung der eigentlichen Operation wurde also
aufgeschoben. Von abstrakten Klassen werden keine Objekte erzeugt.
In Eiffel gilt eine Methode als aufgeschoben (deferred), wenn an stelle der
Anweisungsfolge das Schlüsselwort deferred enthalten ist.
Eine Klasse gilt als deferred, wenn sie eine Methode enthält die
aufgeschoben ist oder eine aufgeschobene Methode erbt und nicht
redefiniert hat. Eine solche Klasse muss in ihrer Deklaration als deferred
class gekennzeichnet sein.
Auch in Java können abstrakte Klassen verwendet werden. Die
Realisierung ist gleich der in Eiffel. Java verwendet bei der Deklaration von
abstrakten Klassen und Methoden das Schlüsselwort abstract.
2.9 Parametrisierbare Klassen
Eine parametrisierbare Klasse (synonym zu generische Klasse) ist eine mit
generischen formalen Parametern versehene Schablone, mit der
gewöhnliche (nicht-generische) Klassen erzeugt werden können. Die
generischen Parameter dienen als Stellvertreter für die aktuellen
Parameter, die Klassen oder einfache Datentypen repräsentieren.
Parametrisierte Klassen sind keine Typen, sondern Typschemata. Erst mit
den aktuellen Parametern werden sie zu Typen. Ohne aktuelle Parameter
kann man ihre Merkmale nicht ausführen und auch nicht austesten.
In Eiffel werden generische Klassen erzeugt, indem bei der
Klassendeklaration hinter den Klassennamen in eckigen Klammern durch
Kommata getrennt formale generische Parameter angegeben werden.
class GENERISCHEKLASSE[X]
...
Eiffel
testaufruf: GENERISCHEKLASSE[INTEGER]
Innerhalb der Klasse kann ein formaler generischer Parameter in allen
Deklarationen wie ein normaler Datentyp eingesetzt werden, sei es als Typ
von Attributen, Methoden, Parametern in Routinen oder von lokalen
Variablen. Nach außen ist der formale generische Parameter unbekannt.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 10 -
Ein Beispiel bei dem die Anwendung gerischer Klassen sinnvoll ist, wäre
ein Listenvergleich. In der generischen Klasse würde dazu eine Methoden
Implementiert werden, welche z.B. zwei Elemente verschiedener Listen
auf Übereinstimmung vergleicht. Durch die Übergabe eines aktuellen
Parameters bei dem Erbvorgang, wird der Datentyp der Elemente
übergeben, welche verglichen werden sollen.
Parametrisierbare Klassen lassen sich nur über Umwege in Java
realisieren. Eine vollständige Implementierung ist in Planung.
2.10 Multiple Vererbung
Wenn eine Unterklasse mehrere direkte Oberklassen hat, spricht man von
multipler Vererbung.
Multiple Vererbung lässt sich in Eiffel realisieren. In der Vererbungsklausel
werden dazu mehrere Oberklassen zusammen mit eventuellen
Modifikationen geerbter features angegeben.
Erbt eine Klasse direkt von mehreren Klassen, so hat sie direkt Zugriff auf
alle features der Oberklassen. Dies kann in manchen Fällen zu
Namenskonflikten führen. Eiffel umgeht dies, indem durch Erbung
vorhandene features mit gleichem Namen umbenannt werden müssen.
Laut Meinung der Java Entwickler führe Multiple Vererbung nur zu
„unnötigen“ Problemen. Daher können Unterklassen immer nur eine
Oberklasse haben. Java hat also nur einfacher Vererbung.
2.11 Wiederholtes Erben
Durch die Möglichkeit der multiplen Vererbung ist eine mehrfache Erbung
der gleichen Klasse
Eiffel
möglich.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 11 -
Bei wiederholtem
Erben von gleichen
Oberklassen ergibt
sich das Problem,
dass die features der
mehrfach geerbten
Klasse ebenfalls
mehrfach vorhanden
sind. Im letzten
Abschnitt wurde
erklärt, dass hierbei
ein Namenskonflikt
auftritt, welcher durch Umbenennung doppelter features mit gleichem
Namen gelöst wird. Dieses Vorgehen macht bei einer wiederholten Erbung
nur dann Sinn, wenn die features nicht gleich sind, also wenn sie von
einer Oberklasse, welche die features wiederum geerbt hat, redefiniert
oder umbenannt wurden. Ist dies nicht der Fall und sind die features
vollkommen identisch, so werden sie als ein feature betrachtet und
vereinigt.
2.12 Zusicherung, Design-by-Contract
Eine wichtige Möglichkeit, die Gefahr von Abweichungen zwischen
Software-Spezifikationen und ihren Implementierungen zu vermindern, ist
die Einführung von Spezifikationselementen in die Implementierung. Dazu
werden Klassen, Methoden oder Attributen Ausdrücke über den Zweck
dieses Elements zugeordnet. Ein solcher Ausdruck, welcher mögliche
Zustände eines solchen Elements angibt wird Zusicherung (Design-by-
Contract oder Programming-by-Contract) genannt.
In Eiffel existieren zur Implementierung solcher Zusicherungen eigene
Prädikate (and, or, and then, or else, not, xor, implies), welche
ausschließlich für diese Zusicherungen eingeführt wurden.
Zusicherungen stellen in Eiffel boolsche-Ausdrücke dar.
n>0 and not x=Void
Dieser boolsche-Ausdruck wird dann erfüllt, wenn n größer 0 und x nicht
leer ist.
Es ist möglich die Zusicherungen während der Laufzeit überwachen zu
lassen. Kommt es durch nicht erfüllte Zusicherungen zu einem Fehler,
kann die Routine entweder selbst innerhalb eines rescue-Bereichs
versuchen diesen
Eiffel
Fehler zu beheben oder dieser Fehler wird an die
aufgerufene Routine zurückgeben, um dort eine Fehlerbehandlung zu
ermöglichen.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 12 -
3. Weitere Besonderheiten
Eiffel Quelltext wird gewöhnlich in Maschinencode (Binär) der
Zielmaschine kompiliert. Es besteht aber auch die Möglichkeit der
Umwandlung von Eiffel-Souce in C-Code. Zudem gibt es die Ansätze
diesen in Bytecode für Java Virtual Machine zu übersetzen.
Zur Entstehungszeit von Eiffel war es üblich die Speicherverwaltung für
eine Anwendung manuell zu Implementieren. Ähnlich wie bei Smalltalk
stellt Eiffel den benötigten Speicher automatisch zu Verfügung. Die
Freigabe von nicht mehr benötigtem Speicherplatz wird mittels des
garbage-collector, ebenfalls ein automatisierten Vorgang, realisiert.
4. Einsatzgebiete
Für Eiffel werden als Anwendungsgebiete, für welche es sich besonders
anbieten soll genannt:
- sicherheitskritische Anwendungen
- Entwurf- und Spezifikationssprachen
- Ausbildung in objektorientierter Programmierung
(Die Angaben sind Aussagen der Eiffel Entwickler selbst und können an
dieser Stelle nicht bestätigt oder verworfen werden.)
5. Fazit
Während meiner Arbeit an diesem Referat und dem dadurch gewonnenem
Eindruck bezüglich der Möglichkeiten von Eiffel, bin ich zu der
Überzeugung gelangt, dass Eiffel die Kriterien erfüllt, auf Grund welchen
Eiffel erschaffen wurde. Eiffel ist vollkommen objektorientiert und dank
seiner ausgefeilten Datenkapselungsmöglichkeiten (spezifischer feature-
Export) ist ein hohes Maß an Sicherheit gewährleistet. Auch sind
Eigenschaften moderner Sprachen, wie automatische Speicherverwaltung
oder die Möglichkeit der Zusicherung in Eiffel bereits implementiert.
Ich persönlich halte die Möglichkeit der multiplen Vererbung für eine
unnötige Quelle von
Eiffel
Fehlern. Die bei sehr großen Projekten eine sehr gute
Planung voraussetzt, um solche zu vermeiden. In Java, welches multiple
Vererbung nicht unterstützt, wird mithilfe von Schnittstellen erreicht, dass
man Eigenschaften von mehreren Klassen erben kann. Ich halte diesen
Ansatz für sinnvoller im Vergleich zur multiplen Vererbung.

Objektorientierte Programmiersprachen am Beispiel Eiffel - 13 -
6. Literatur
Meyer, Bertrand: EIFFEL The language
Prentice Hall International (UK) Ltd; 1992; I. Reprint
ISBN: 0-13-247925-7
Switzer, Robert: EIFFEL An Introduction
Prentice Hall International (UK) Ltd; 1993; II. Series
ISBN: 0-13-105909-2
Oestereich, Bernd: Objektorientierte Softwareentwicklung
R. Oldenbourg Verlag München Wien; 1998; 4. Auflage
ISBN: 3-486-24787-5
Gumm, Sommer: Einführung in die Informatik
R. Oldenbourg Verlag München Wien; 2002; 5. Auflage
ISBN: 3-486-25635-1
Schildt, Herbert: Java 2 Ent-Packt
MITP-Verlag GmbH, Bonn; 2001; 1. Auflage
ISBN: 3-8266-0736-8
Eiffel