Wikia

Mini-Wikia

Fantom-DE/Struktur

< Fantom-DE

2.025Seiten in
diesem Wiki
Diskussion0

Fantom-Programme werden durch drei primäre Abstraktionen gegliedert:

  • Pods: Module für das Deployment und die Versionierung
  • Typen: Die grundlegende Einheiten des objektorientierten Typsystems
  • Slots: Felder und Methoden

Diese Abstaktionen sind in einem dreistufigen Namensraum organisiert; dabei wird die folgende Syntax für qualifizierte Namen verwendet:

  • pod
  • pod::Typ
  • pod::Typ.slot

Alle drei Ebenen wollen wir im Folgenden etwas näher beleuchten.

PodsBearbeiten

Pods bilden die Spitze des Fantom-Namensraums und gleichzeitig die Einheit für das Deployment. Der Name eines Pod ist global eindeutig und dient dazu, die oberste Ebene des Fantmon-Namensraums zu organisieren. Pod-Namen ähneln den Packages in Java oder den Namensräumen in C#. Um die Eindeutigkeit zu wahren sollten eine Namenskonvention angewendet werden, die keine Konflikte hervorruft (siehe Konventionen).

Pods bilden auch die fundamentale Einheit für das Deployment, die Versionierung und das Management von Abhängigkeiten. In dieser Rolle sind sie mit JAR-Dateien in Java und DLLs in .NET zu vergleichen. Ein Pod ist eine standardmäßige ZIP-Datei, in der die Fantom-Programme für die Typen des Pod, die Metadaten und ggf. benötigte Dateiressourcen gebündelt sind.

Der Typ sys::Pod bildet die Reflection-API für die Arbeit mit Pods, die in einem bestimmten Fantom-System installiert sind. Hier sind einige Code-Beispiele für gängige Pod-Operationen:

Pod.list                       // alle installierten Pods auflisten
Pod.find("acmeFoo")            // einen Pod finden (löst Exception aus, wenn Pod nicht zu finden ist)
Pod.find("acmeFoo", false)     // eine Pod finde (gibt null zurück, wenn Pod nicht zu finden ist)
myPod.file(`/img/icon.png`)    // eine Ressource-Datei in myPod finden
`fan://myPod/img/icon.png`.get // eine Ressource-Datei in myPod finden
Pod.of(someObj)                // den Pod eines Objekts erhalten

Weitere Einzelheiten lesen Sie im Kapitel Pods.

TypenBearbeiten

Ein Typ ist eine objektorientierte Klasse, die Zustand und Verhalten kapselt. Jeder Typ gehört zu einem Pod und wird durch einen Namen identifiziert, der innerhalb seines Pods eindeutig ist. Der doppelte Doppelpunkt :: dient dazu, Pod- und Typennamen zu verbinden einen qualifizierten Namen oder Q-Namen zu erhalten.

Da Pod-Namen global eindeutig sind, ist auch der Q-Name eines Typs global eindeutig. Beispielsweise ist sys::Str der Q-Name des Typs Str, der zum Pod sys gehört.

Typen gibt es in Fantom in zwei Varianten: Klassen und Mixins.

Der Typ sys::Type stellt die Reflektion-API für die Arbeit mit Typen zur Laufzeit zur Verfügung. Hier sind einige Code-Stückchen für übliche Typ-Operationen:

Type.of(someObj)          // Typ von someObj erhalten
myPod.types               // Liste der in myPos enthaltenen Typen
myPod.findType("Foo")     // Einen Typ in myPod anhand des einfachen Namens finden
Type.find("myPod::Foo")   // Einen Typ anhand des qualifizierten Namens finden
Int#                      // Typliteral für sys::Int
someType.fits(Num#)       // reflektive Version des is-Operators


Slots Bearbeiten

Typen kapseln Zustand und Verhalten als eine Sammlung von Slots. Jeder Slot hat einen innerhalb seines Typs eindeutigen Namen. Der Punkt (.) dient dazu, mit Hilfe des Elterntyp-namens den Q-Namen des Slots zu bilden. Beispielsweise ist sys::DateTime.now der global eindeutige, qualifiziete Name, der die Methode now innerhalb des Typs DateTime innerhlab des Pod sys identifiziert.

Es gibt zwei Typen von Slots:

  • Methoden modellieren Verhalten
  • Felder modellieren Zustand

Der Typ sys::Slot stellt die Reflection-API für die Arbeit mit Slots zur Laufzeit dar. Hier sind einige Beispiele für häufig verwendete Slot-Operationen:

someType.slot("xyz")         // den Slot namens xyz zu einem Typ finden
Slot.find("myPod::Foo.xyz")  // den Slot anhand seines qualifizieten Namens finden
method.call([arg0, arg1])    // Methdoenaufruf mittels Reflection
method.func                  // die implementierende Funktion einer Methode
field.get(instance)          // ein Feld per Reflection auslesen
SomeType#xyx                 // Slot-Literal für ein Slot in SomeType
#xyx                         // Slot-Literal für den aktuellen Typ
Typische Operationen mit Slots
Code Bedeutung
someType.slot("xyz") den Slot namens xyz zu einem Typ finden
Slot.find("myPod::Foo.xyz") den Slot anhand seines qualifizieten Namens finden
method.call([arg0, arg1]) Methdoenaufruf mittels Reflection
method.func die implementierende Funktion einer Methode
field.get(instance) ein Feld per Reflection auslesen
SomeType#xyx Slot-Literal für ein Slot in SomeType
#xyx Slot-Literal für den aktuellen Typ

Alle Slots sind durch einen eindeutigen Namen gekennzeichnet. Das bedeutet, Fantom untersützt keine Methoden, die wie in Java oder C# durch Parametertypen überschrieben werden. Dies kann unter Umständen eine Behinderung darstellen; aber ist gibt eine Reihe von Möglichkeiten in Fantom, die diese Einschränkung recht erträglich werden lassen. Erstens können Methodenparameter Vorgabewerte haben - dadurch werden viele überschriebene Methoden überflüssig, die in Java- und C#-APIs der Bequemlichkeit dienen. Zweitens sind alle Typen von Obj abgeleitet - dadurch wird eine solche Aufblähung von APIs überflüssig, die zur Unterstützung aller primitiver Typen erforderlich ist, wie es etwa bei java.io.PrintWriter der Fall ist. Schliesslich sind Konstruktoren in Fantom benannt, und dadurch wird ein weiteres verbreitetes Erfordernis für typbasiertes Überladen überflüssig. Der Vorteil dieser Einschränkung ist die wirklich schöne Möglichkeit, Methoden nur anhand ihres Namens oder Q-Namens zu finden, wodurch reflektive Programmierung und dynamische Aufrufe um ein Vielfaches einfacher werden.

Methoden Bearbeiten

Methdoden stellen in Fantom die elementare Einheit für das Kapseln von Verhalten dar. Im Grunde sind Methoden nur Wrapper, die eine Funktion in einen Slot verpacken. Jede Methode hat einen Rückgabetyp und null oder mehr typisierte Parameter. Methoden, die kein Objekt zurückgeben, haben den Rückgabetyp sys::Void.

Die API sys::Method dient dazu, zur Laufzeit reflektiv mit Methoden zu arbeiten.

Ausführlicher erörtert werden Methoden in Methoden.

Felder Bearbeiten

Felder dienen dazu, innerhalb eines bestimmten Typs den Zustand zu modellieren. In Fantom sind Felder aus drei Konzepten zusammengesetzt:

  • Getter: eine Methode, mit der man auf den aktuellen Werte des Feldes zugreifen kann
  • Setter: eine Methode, mit der man den aktuellen Wert des Feldes ändern kann
  • Speicher: ein Ort im Arbeitsspeicher, in dem der aktuelle Wert abgelegt ist

Die meisten Felder haben alle drei Komponenten, aber typischerweise werden Getter und Setter vom Compiler automatisch generiert. Konstante (const) Felder haben nur eine Speicher, aber weder Getter noch Setter. Fantom lässt auch abstrakte und berechnete Felder zu, die zwar Getter und Setter haben, aber keinen Speicher.

Die API sys::Field dient dazu, zur Laufzeit reflektiv zum Feldern zu arbeiten.

Einen tieferen Einblick in Felder gibt es in Felder.

Aus dem Wikia-Netzwerk

Zufälliges Wiki