imported>Player2072: Schreibweise.

2025-07-30T11:37:06Z

Schreibweise.

Neue Seite

{{Infobox Programmiersprache
| Name =
| Logo = [[Datei:Oberon programming language logo.svg|150px]]
| Beschreibung =
| Paradigma = [[Imperative Programmierung|imperativ]], [[Strukturierte Programmierung|strukturiert]], [[Objektorientierte Programmierung|objektorientiert]]
| Erscheinungsjahr = 1987
| Designer =
| Entwickler = [[Niklaus Wirth]], [[Jürg Gutknecht]]
| AktuelleVersion =
| AktuelleVersionFreigabeDatum =
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung =
| Implementierung =
| Dialekte =
| Standardisierungen =
| Beeinflusst_von = [[Pascal (Programmiersprache)|Pascal]], [[Modula-2]]
| Beeinflusste = [[Component Pascal]], [[Active Oberon]], [[Zonnon]]
| Betriebssystem =
| Lizenz = unbekannt
| Website =
}}
'''Oberon''' ist eine von [[Niklaus Wirth]] und [[Jürg Gutknecht]] entwickelte, [[Objektorientierte Programmierung|objektorientierte]], streng strukturierte [[Programmiersprache]]. Sie ist den ebenfalls von Wirth entworfenen Vorgängern [[Pascal (Programmiersprache)|Pascal]] und [[Modula-2]] recht ähnlich, allerdings strukturierter und [[Mächtigkeit (Mathematik)|mächtiger]] als Pascal, gleichzeitig aber erheblich weniger umfangreich als Modula-2. Die Definition der Sprache war Anfang 1986 abgeschlossen. Das [[Oberon System]] ist ein eigenständiges [[Betriebssystem]] der [[ETH Zürich]], das in der Sprache Oberon implementiert ist, als Entwicklungsgrundlage für die Sprache diente und ebenso wie der Compiler kostenlos erhältlich war.

== Überblick ==

=== Einordnung ===
Oberon ist das Ergebnis eines Forschungsprojekts, eine Programmiersprache und ein Betriebssystem für Arbeitsplatzrechner zu entwickeln. Wirth und Reiser führten die Motivation für das Projekt auf die Zeit der Implementierung des [[Personal Computer|persönlichen Rechners]] zurück. So hätten die damaligen üblichen Betriebssysteme beim Umsetzen der Prinzipien der [[Softwaretechnik]] versagt. Dazu seien eine voreilige Flucht in Standards gekommen sowie [[Computerprogramm|Programme]], die Schichten auf veraltete Grundsysteme stapelten. Die Softwaretechnik habe einen wirtschaftlichen Mitteleinsatz und die Einfachheit der Lösungen vermissen lassen. Als Leitmotiv für das Projekt zitierten sie [[Albert Einstein|Einstein]]: „Mach es so einfach wie möglich, aber nicht einfacher.“<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=XV–XVI}}</ref> Das Projekt wurde nach dem größten Mond des Planeten [[Uranus (Planet)|Uranus]] benannt, dessen Monde zu dieser Zeit von der Raumsonde [[Voyager 2]] fotografiert wurden. Oberon sei auch der Name des [[Oberon (Elfenkönig)|Elfenkönigs]].<ref>{{Literatur |Autor=Niklaus Wirth, Jürg Gutknecht |Titel=Project Oberon. The Design of an Operating System and Compiler |Verlag=Addison-Wesley |Datum=1992 |Sprache=en |ISBN=0-201-54428-8 |Seiten=3}}</ref>

Die Entwicklung von Oberon begann 1985 und mündete in einer vollständigen Definition der Sprache Anfang 1986 als Ergebnis einer Kooperation zwischen Niklaus Wirth und Jürg Gutknecht. Der dazu veröffentlichte Report umfasst lediglich circa 16 Seiten.<ref>{{Literatur |Autor=Niklaus Wirth |Titel=Modula-2 and Oberon |Sammelwerk=HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages |Verlag=ACM, Inc. |Datum=2007-06-09 |Sprache=en |Seiten=3-8}}</ref><ref>{{Literatur |Autor=Niklaus Wirth |Titel=From Modula to Oberon and the programming language Oberon |Sammelwerk=Institut für Informatik, Fachgruppe Computer-Systeme |Band=82 |Verlag=Eidgenössische Technische Hochschule Zürich |Datum=1987-09 |Sprache=en |Umfang=27 Seiten |DOI=10.3929/ethz-a-005363226 |Online=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/68917/eth-3189-01.pdf |Format=PDF |KBytes=1485 |Abruf=2020-01-02}}</ref>

Ein Ziel der Programmiersprache Oberon war es, den erweiterbaren [[Entwerfen|Entwurf]] zu unterstützen. Während ihr Vorgänger [[Modula-2]] zwar strukturierte, modulare und hierarchische Programmierung erlaubt, um Abstraktionsebenen einzuführen, fügt Oberon die Erweiterbarkeit von [[Datentyp]]en hinzu und zwar derart, dass erweiterte Typen kompatibel mit ihren Ausgangstypen bleiben. Modula-2 bietet dieses Merkmal nicht. Reiser und Wirth sahen darin die eigentliche Neuerung der „in den achtziger Jahren zur Modewelle avancierten [[Objektorientierte Programmierung|objektorientierten Sprachen]].“ Diese hätten darüber hinaus mit dem Ziel eines Paradigmenwechsels altbekannte Konzepte umbenannt. Aus [[Variable (Programmierung)|Variablen]] wurden [[Objekt (Programmierung)|Instanzen]], aus [[Prozedur (Programmierung)|Prozeduren]] [[Methode (Programmierung)|Methoden]] und aus dem Prozeduraufruf das Senden von Meldungen. Oberon hingegen blieb bei den Begriffen des Datentyps und der Prozedur, um einen „Bruch mit der Tradition“ zu vermeiden.<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=4–5}}</ref>

Die nachfolgende Tabelle zeigt einen Terminologienvergleich zwischen der objektorientierten Programmierung (OOP) und Oberon.<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=249}}</ref>

{| class="wikitable sortable mw-collapsible mw-collapsed" style="margin-top: 0; margin-left: 2em; text-align: left;"
|+ Terminologienvergleich
|-
! OOP-Terminologie
! Oberon-Terminologie
|-
| Klasse
| Zeigertyp, der einen Record-Typ mit Prozedurvariablen referenziert, welcher einen abstrakten Datentyp definiert
|-
| Objekt
| Zeigervariable, die auf eine Record-Variable dieses Typs zeigt
|-
| Methode
| Eine Prozedur des Record-Typs
|-
| Meldung senden
| Aufruf einer dynamisch gebundenen Prozedur
|-
| Unterklasse (Subclass)
| Erweiterter Record-Typ
|-
| Oberklasse (Superclass)
| Basistyp einer Erweiterung
|-
| Vererbung (Inheritance)
| Typerweiterung
|-
| Überschreiben einer Methode
| Ändern der einem Record-Feld zugewiesenen Prozedur in einer Erweiterung
|-
| Empfänger (Receiver)
| Das als Parameter übergebene Objekt bei einem Prozeduraufruf
|-
| Super-Aufruf
| Aufruf einer Prozedur, die an den Basistyp einer Erweiterung gebunden ist
|-
| Dynamisches Binden
| Aufruf einer Prozedurvariablen
|}

Oberon hat im Vergleich zu seinem Vorgänger Modula-2 einen verminderten Befehlsumfang. In der damit erreichten Vereinfachung und Vereinheitlichung sahen Reiser und Wirth „echten Fortschritt“ beim Vermitteln wissenschaftlicher Grundlagen, da die Ausdruckskraft Oberon erhalten bliebe.<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=5}}</ref>

Oberon wurde wie auch schon Modula-2 parallel zu einer Workstation, in diesem Fall [[Ceres (Computersystem)|Ceres]], entwickelt. Oberon fand nach seiner Veröffentlichung unter anderem zu Bildungszwecken in Lehreinrichtungen Verwendung. Es existierten seinerzeit auf Oberon basierende, ebenfalls kostenlos verfügbare Werkzeuge, die auch kommerziell eingesetzt wurden, wie zum Beispiel die Programmiersprache [[Component Pascal]] und die [[integrierte Entwicklungsumgebung]] [[BlackBox Component Builder]].

Wirth veröffentlichte Revisionen von Oberon in den Jahren 2007 und 2016.<ref>{{Literatur |Autor=Niklaus Wirth |Titel=The Programming Language Oberon |Datum=2016 |Sprache=en |Seiten=1 |Online=https://people.inf.ethz.ch/wirth/Oberon/Oberon07.Report.pdf}}</ref> Im Rückblick wies er darauf hin, dass Oberon (im Jahr 2021) an „vielen Stellen“ im Einsatz gewesen sei, konstatierte jedoch, dass ein Durchbruch von Oberon im Gegensatz zu Pascal aufgrund „komplexer, kommerzieller Systeme mit weiter Verbreitung“ nicht stattgefunden habe.<ref>{{Literatur |Autor=Niklaus Wirth |Titel=Viewpoint: 50 Years of Pascal |Sammelwerk=Communications of the ACM |Band=64 |Nummer=3 |Verlag=Association for Computing Machinery |Datum=2021-03 |Sprache=en |Seiten=41}}</ref>

=== Besonderheiten ===
[[Hanspeter Mössenböck]] und Wirth haben Oberon mit wenigen Ergänzungen zur Programmiersprache '''Oberon-2''' weiterentwickelt, die kompatibel zu Oberon ist. Wesentlich ist die Aufnahme von Prozeduren in den Befehlsumfang, die als Teil des Datentyps eines Objekts definiert werden können. Eine solche Prozedur erhält stets bei ihrem Aufruf eine Referenz auf das Objekt, über das ihr Aufruf erfolgt ist. Bei Oberon muss in diesem Fall eine Prozedur zunächst einer Prozedurvariablen des Objekts zur Laufzeit zugewiesen und, sofern benötigt, eine Referenz auf das Objekt als [[Parameter (Informatik)|Parameter]] der Prozedur bei ihrem Aufruf übergeben werden. Ferner wurden unter anderem die [[For-Schleife]] und die Exportmarkierung <code>-</code> (als Alternative zu <code>*</code>) eingeführt, letzteres, um Variablen oder Objektkomponenten schreibgeschützt sichtbar zu machen.<ref name=":0">{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=277–279, 288}}</ref>

Mössenböck bezeichnet die Frage, ob die Konzepte des [[Modul (Software)|Moduls]] und der [[Klasse (Objektorientierung)|Klasse]] in Oberon gleichzeitig vorhanden sein müssten, als berechtigt, da beide eine Datenstruktur verstecken und nur über Prozeduren zugänglich machen können. Er begründet das gleichzeitige Vorhandensein mit einer unterschiedlichen Sichtbarkeit. Das Modul regelt die Sichtbarkeit von außen, während innerhalb eines Moduls sämtliche Bestandteile der enthaltenen Klassen sichtbar sind.<ref>{{Literatur |Autor=Hanspeter Mössenböck |Titel=Object-Oriented Programming in Oberon-2 |Auflage=2 |Verlag=Springer-Verlag |Datum=1994 |Sprache=en |Seiten=43 |Online=https://ssw.jku.at/Research/Books/Oberon2.pdf}}</ref>

Oberon sieht verglichen beispielsweise mit dem standardmäßigen Verhalten von [[C++]]<ref>{{Literatur |Autor=Bjarne Stroustrup |Titel=A Tour of C++ – Third Edition |Verlag=Pearson Education, Inc. |Datum=2023 |Sprache=en |ISBN=978-0-13-681648-5 |Seiten=79 |Zitat=In C++, you can plug in a garbage collector. However, I consider garbage collection the last choice after cleaner, more general, and better localized alternatives to resource management have been exhausted.}}</ref> eine [[Garbage Collection|automatischen Speicherbereinigung]] (''garbage collection'') vor.<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=146}}</ref> Damit wird die Verwendung von Programmanweisungen zur [[Allokation (Informatik)|Deallokation]] des von Objekten im [[Dynamischer Speicher|Heap]] belegten Speichers obsolet. Wird erneut freier Speicher für ein Objekt im Heap benötigt, wird dort zunächst der Speicher von allen Objekten freigegeben, die aus keinem der geladenen Module mehr referenziert werden.<ref>{{Literatur |Autor=Niklaus Wirth, Jürg Gutknecht |Titel=Project Oberon. The Design of an Operating System and Compiler |Verlag=Addison-Wesley |Datum=1992 |Sprache=en |ISBN=0-201-54428-8 |Seiten=241}}</ref>

Oberon verlangt, dass Operanden in Ausdrücken und die Bestandteile von Wertzuweisungen kompatibel sind, und nennt diese Forderung strenge [[Typisierung (Informatik)|Typisierung]]. Ein [[Compiler]] kann so prüfen, ob Ausdrücke oder Zuweisungen sinnvoll sind, so dass Programmierfehler bereits vor der Programmausführung erkannt werden.<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=48}}</ref>

Der im Rahmen des Oberon-Projekts von Wirth und Gutknecht entwickelte Compiler – Wirth hielt die Entwicklung einer Programmiersprache ohne einen dazugehörigen Compiler für anmaßend und unprofessionell –<ref>{{Literatur |Autor=Niklaus Wirth |Titel=From Programming Language Design to Computer Construction |Sammelwerk=Communications of the ACM |Band=28 |Nummer=2 |Verlag=Association for Computing Machinery |Datum=1985-02 |Sprache=en |Seiten=164}}</ref> für die [[NS320xx|NS-32000-Mikroprozessorarchitektur]] hatte zum Ziel, selbst kompakt zu sein und eine schnelle Übersetzung von [[Quelltext]] in effizienten und knappen [[Maschinensprache|Maschinencode]] aufzuweisen.<ref>{{Literatur |Autor=Niklaus Wirth, Jürg Gutknecht |Titel=Project Oberon. The Design of an Operating System and Compiler |Verlag=Addison-Wesley |Datum=1992 |Sprache=en |ISBN=0-201-54428-8 |Seiten=VI}}</ref> Der erzeugte Maschinencode überprüft standardmäßig zur Laufzeit, ob der für einen Zugriff auf ein [[Array (Datentyp)|Array]]-Element verwendete Index in dem Bereich liegt, der bei der [[Deklaration (Programmierung)|Deklaration]] des Arrays im Quelltext angegeben wurde. Ist dies nicht der Fall, liegt ein Fehler vor und die Programmausführung wird abgebrochen. Da die Indexprüfung einen zusätzlichen Laufzeitaufwand nach sich zieht, erlauben dieser und andere Compiler, sie per Option abzuschalten.<ref>{{Literatur |Autor=Niklaus Wirth, Jürg Gutknecht |Titel=Project Oberon. The Design of an Operating System and Compiler |Verlag=Addison-Wesley |Datum=1992 |Sprache=en |ISBN=0-201-54428-8 |Seiten=338, 360}}</ref><ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=120}}</ref>

Der Compiler erzeugt ebenso eine Liste von Zuordnungen zwischen Prozeduren und Variablen im Quelltext und dem entsprechend erzeugten Maschinencode. Damit kann im Fehlerfall bei einem Programmabbruch der letzte Zustand der Programmausführung angezeigt werden hinsichtlich der Folge der aufgerufenen Prozeduren und deren Variablen. Das dazu verwendete Werkzeug ist üblicherweise ein symbolischer [[Debugger]].<ref>{{Literatur |Autor=Niklaus Wirth, Jürg Gutknecht |Titel=Project Oberon. The Design of an Operating System and Compiler |Verlag=Addison-Wesley |Datum=1992 |Sprache=en |ISBN=0-201-54428-8 |Seiten=449, 451}}</ref>

Die Quelltexte der Compiler waren in der Regel frei verfügbar. Es gab verschiedene integrierte Entwicklungsumgebungen wie zum Beispiel [[POW!]].<ref>{{Internetquelle |autor=Peter René Dietmüller |url=http://www.fim.uni-linz.ac.at/pow/pow.htm |titel=Pow! - Programmers Open Workbench |datum=2005-09-08 |sprache=en |abruf=2022-10-05 |kommentar=eine IDE zu Oberon}}</ref>

Die Zeit, die ein Compiler benötigt, um seinen eigenen Quelltext in Maschinencode zu übersetzen, auch Selbstübersetzungszeit genannt, kann als Maß für die Qualität des Compilers angesehen werden.<ref>{{Literatur |Autor=Michael Franz |Titel=Oberon – The Overlooked Jewel |Hrsg=László Böszörményi, Jürg Gutknecht, Gustav Pomberger |Sammelwerk=The School of Niklaus Wirth: The Art of Simplicity |Verlag=dpunkt-Verlag |Ort=Heidelberg |Datum=2000 |Sprache=en |ISBN=3-932588-85-1 |Seiten=44 |Online=https://people.cis.ksu.edu/~danielwang/Investigation/System_Security/download.pdf |Zitat=He [Wirth] used the compiler’s self-compilation speed as a measure of the compiler’s quality.}}</ref> Die Selbstübersetzungszeit eines Oberon-2-Compilers betrug im Jahr 1991 mit einer [[DECstation|DECstation 5000]] ([[MIPS-Architektur|MIPS R3000]], 25 [[Megahertz]]) lediglich 7 Sekunden.<ref>{{Literatur |Autor=Marc M Brandis, Régis Crelier, Michael Franz, Josef Templ |Online=https://fruttenboel.nl/Oberon/data/p_obesys.pdf |Titel=The Oberon System Family |Sammelwerk=Software - Practice and Experience |Band=25 (12) |Hrsg=Institut für Computersysteme, ETH Zürich, Schweiz |Datum=1995-12 |Seiten=1331–1366 |Sprache=en |Abruf=2024-11-29}}</ref> (''Anmerkung:'' Auf modernen Computern ist die [[Taktsignal|Taktrate]] über einhundert Mal schneller, und die Selbstübersetzungszeit beträgt damit deutlich weniger eine Zehntelsekunde. ''Zum Vergleich'': Im Jahr 1985 dauerte die Selbstübersetzung für den Modula-2-Compiler von Niklaus Wirth auf einem [[Lilith (Computersystem)|Lilith-Computer]] (vergleichbare Rechenleistung wie eine [[Virtual Address eXtension|VAX 750]]) knapp zwei Minuten.<ref>{{Literatur |Autor=Niklaus Wirth |Titel=A Fast and Compact Compiler for Modula-2 |Hrsg=ETH Zürich - Institut für Informatik |Ort=Zürich |Datum=1985-07 |Sprache=en |Seiten=2 |Online=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/69199/eth-3296-01.pdf?sequence=1&isAllowed=y}}</ref>)

== Code-Beispiele ==
Hello World im Ulmer Oberon-System:<ref>{{Internetquelle |autor=Andreas Borchert |url=https://www.mathematik.uni-ulm.de/oberon/0.5/lib/man/Streams.html |titel=Ulm's Oberon Library: Streams |datum=2004-05-22 |sprache=en |abruf=2024-11-24}}</ref>

<syntaxhighlight lang="componentpascal">
MODULE HelloWorld;

IMPORT Write;

BEGIN

Write.Line ("Hello World");

END HelloWorld.
</syntaxhighlight>

Die objektorientierte Programmierung wird mit erweiterten [[Verbund (Datentyp)|Datenverbünden]] vom [[Datentyp]] <code>RECORD</code> erreicht. Die Definition von Methoden wird durch typengebundene Prozeduren, und die Definition von Sichtbarkeiten durch Exportmarkierungen (<code>*</code> für Schreib- und Lesezugriff und <code>-</code> für Lesezugriff) erwirkt. Beispiel in Oberon-2:

<syntaxhighlight lang="componentpascal">
MODULE Vererbung;

TYPE

GraphischesObjekt* = POINTER TO GraphischesObjektBeschreibung; (* Das nachgestellte Malzeichen kennzeichnet einen Datentyp, der exportiert wird *)
GraphischesObjektBeschreibung = RECORD farbe*: LONGINT; END; (* Das nachgestellte Malzeichen kennzeichnet ein exportiertes Attribut, auf das wahlfrei zugegriffen werden kann *)

Punkt* = POINTER TO PunktBeschreibung;
PunktBeschreibung = RECORD (GraphischesObjekt) x*, y*: LONGINT; END; (* Punkt erbt die Eigenschaft "farbe" von GraphischesObjekt *)

Linie* = POINTER TO LinienBeschreibung;
LinienBeschreibung = RECORD (GraphischesObjekt) xStart*, yStart*, xEnde*, yEnde*: LONGINT; END; (* Linie erbt die Eigenschaft "farbe" von GraphischesObjekt *)

PROCEDURE (punkt: Punkt) Zeichne*; (* typgebundene Methode "Zeichne" für Instanzen vom Typ "Punkt" *)
BEGIN
...
END Zeichne;

PROCEDURE (linie: Linie) Zeichne*; (* typgebundene Methode "Zeichne" für Instanzen vom Typ "Linie" *)
BEGIN
...
END Zeichne;

CONST

ROT = 00000FFH; (* RGB *)

VAR

punkt: Punkt;
linie: Linie;

BEGIN

NEW (punkt);
punkt.farbe := ROT;
punkt.x := 1;
punkt.y := 1;
punkt.Zeichne ();

NEW (linie);
punkt.farbe := ROT;
linie.xStart := 1;
linie.yStart := 1;
linie.xEnde := 2;
linie.yEnde := 2;
linie.Zeichne ();

END Vererbung.
</syntaxhighlight>

Attribute, die nur einen Lesezugriff haben, können durch typengebundene Prozeduren (Methoden) verändert werden. Beispiel in Oberon-2:<ref>{{Literatur |Autor=Martin Reiser, Niklaus Wirth |Titel=Programmieren in Oberon – Das neue Pascal |Auflage=1. |Verlag=Addison-Wesley |Datum=1995 |ISBN=3-89319-657-9 |Seiten=144}}</ref><ref name=":0" />

<syntaxhighlight lang="componentpascal">
MODULE Schreibschutz;

TYPE

Objekt* = POINTER TO Objektbeschreibung; (* Das nachgestellte Malzeichen kennzeichnet einen Datentyp, der exportiert wird *)
Objektbeschreibung = RECORD x-: INTEGER; END; (* Das nachgestellte Minuszeichen kennzeichnet ein exportiertes Attribut, auf das nur lesend zugegriffen werden kann *)

PROCEDURE (objekt: Objekt) SetzeX* (wert: INTEGER); (* typgebundene Methode "SetzeX" *)
BEGIN
objekt.x := wert; (* Schreibzugriff auf das Attribut "x" nur in typgebundener Methode *)
END SetzeX;

VAR

objekt: Objekt;
int: INTEGER;

BEGIN

NEW (objekt); (* Erzeugen einer anonymen Variable vom Typ "Objektbeschreibung" und Initialisieren des Zeigers "objekt", der damit diese Variable referenziert *)
objekt.SetzeX (1); (* Schreibzugriff auf das Attribut "x" nur über Methodenaufruf *)
int := objekt.x; (* Lesezugriff auf das Attribut "x" auch über Zuweisung *)

END Schreibschutz.
</syntaxhighlight>

== Weiterentwicklungen ==
Ausgehend von Oberon und Oberon-2 sind die Programmiersprachen [[Component Pascal]], [[Active Oberon]] und [[Zonnon]] entstanden.

== Siehe auch ==
* [[Oberon microsystems]]

== Literatur ==
* Hanspeter Mössenböck: [https://ssw.jku.at/Research/Books/Oberon2.pdf ''Object-Oriented Programming in Oberon-2.''] 2. Auflage. Springer-Verlag, 1993, 1994 (englisch)
* {{BibISBN|3-89319-657-9|Kommentar=2. korrigierter Nachdruck 1997}}
* {{BibISBN|0-201-56543-9}}
* {{BibISBN|0-201-54428-8}}
* {{BibISBN|0-201-54422-9}}

== Weblinks ==
* {{Internetquelle
|url=http://projectoberon.net/
|titel=Project Oberon
|datum=2021-01-10
|abruf=2023-11-16
|kommentar=Project Oberon is a design for a complete desktop computer system from scratch.}}

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4248282-3}}

[[Kategorie:Freeware]]
[[Kategorie:Imperative Programmiersprache]]
[[Kategorie:Objektorientierte Programmiersprache]]
[[Kategorie:Bildungsorientierte Programmiersprache]]

Oberon (Programmiersprache) - Versionsgeschichte

imported>Player2072: Schreibweise.