A Java és a C# nyelvhez hasonlóan a nyelv teljes egészében osztály alapú.
Tagok
Láthatóság
Az osztályok tagjaira ugyanazok a láthatósági szabályok érvényesek, mint az osztályokra.
Konstansok
Konstansok: Az osztály konstans változói. Értékük nem változhat futási időben.
type
MyClass = class
const
i1: Integer = 5;
i2 = 10;
…
end;
Konstruktorok
Konstruktorok: A konstruktor egy speciális metódus, amit az egy példányának létrehozásához és inicializálásához használunk. Az Oxygene név nélküli konstruktorokat használ. Lehetőség van konstruktorok túlterhelésére is azaz különböző paraméterű konstruktorokat adhatunk meg. Példák:
type
MyClass = class
public
constructor;
constructor(aValue: String);
end;
…
constructor MyClass;
begin
… // instance initialization goes here.
end;
constructor MyClass(aValue: String);
begin
constructor; // call other constructor
… // initialization based on aValue.
end;
Ezenk kívül létezik egy speciális konstruktor is az osztály konstruktor. Ez akkor hívódik meg, amikor az osztály első példányát létrehozzuk. Ez nem túlterhelhető és paraméter nélküli. Példa:
class constructor MyClass;
begin
… // class initialization goes here.
end;
Sokszor első művelet egy osztály létrehozásakor – objektum bizonyos mezőinek beállítása. Pl.:
with p := new Point(param1, param1) do begin
p.x := 10;
p.y := 20;
// other code
end;
Oxygen lehetőséget nyújt arra, hogy ezeket a „nevesített paraméterek” konstruktor paraméterei után helyezzünk el megfelelő beállítandó értékkel ellátva:
with p := new Point(param1, param1, x := 10, y := 20) do begin
// code
end;
Események (events)
Események (events): Az Oxygene lehetőséget biztosít saját események létrehozására is.
type
TMyClass = class(…)
public
event MyEvent: EventHandler;
end;
Vagy részletesen kiírva:
type
TMyClass = class(…)
private
fMyEvent: EventHandler;
public
event MyEvent: EventHandler delegate fMyEvent;
end;
Egy esemény 3 műveletet támogat: add, remove raise. Alapértelmezetten fordító generálja a műveletekhez tartozó metódusokat. De szükség esetén ezek helyettesíthetőek (raise nyelv 3. verziótól kezdve helyettesíthető) saját metódusokkal. Pl.:
type
MyDelegate = delegate (Sender: Object; Args: EventArgs);
MyInterface = interface
event MyEvent: MyDelegate;
event MyRaiseEvent: MyDelegate add remove raise;
end;
MyClass = class(MyInterface)
private
fMember: MyDelegate;
method AddExplicitEvent(param: MyDelegate);
method RemoveExplicitEvent(param: MyDelegate);
method RaiseExplicitEvent(sender: Object; Args: EventArgs);
public
event MyEvent: MyDelegate delegate fMember;
event MyRaiseEvent: MyDelegate add remove raise;
event ExplcitEvent: MyDelegate add AddExplicitEvent remove RemoveExplicitEvent raise RaiseExplicitEvent;
end;
Adatmezők (fields)
Adatmezők (fields): Olyan változók, amiket az osztály példányai közösen használnak.
type
MyClass = class
private
fField1: Integer;
fField2: Integer := 5;
fField3: Integer; readonly;
fField5: SomeClass; implements ISomeInterface;
fField6: Hasttable := new Hashtable();
var
fField4: String;
fField5: double;
class var
fClassField1: String;
fClassField2: Double := 5;
…
end;
Destruktorok
Destruktorok: Az Oxygene tartalmaz szemétgyűjtést, azonban lehetőség van destruktor írására is. Erre szolgál a "finalizer" kulcsszó. Példa:
type
MyClass = class
public
…
finalizer;
end;
…
finalizer MyClass;
begin
… // cleanup goes here
end;
Ha egy osztály külső forrásokat is használ (pl. adatbázis), akkor Microsoft ajánlja, hogy következő mintát használjuk megírásakor:
private
disposed: Boolean;
method Dispose(disposing: Boolean);
public
...
method Dispose;
finalizer Finalize;
end;
...
method MyClass.Dispose;
begin
Dispose(true);
GC.SuppressFinalize(self);
end;
method MyClass.Dispose(disposing: Boolean);
begin
if not disposed then
begin
if disposing then
begin
// Dispose of managed resources.
end;
// Dispose of unmanaged resources
disposed := true;
end;
end;
finalizer MyClass.Finalize;
begin
Dispose(false);
end;
Bejárók (iterators)
Bejárók (iterators): Ennek segítségével az osztály egy metódusa úgy viselkedik, mint egy bejárható adatszerkezet. Példa: (négyzetet számol az adott intervallumon):
interface
uses System.Collections.Generic;
type
Counter = public class
public
method Squares(aBegin, aEnd: Integer): IEnumerable; iterator;
end;
method Counter.Squares(aBegin, aEnd: Integer): IEnumerable;
var i2: Integer;
begin
for i: Integer := aBegin to aEnd do begin
i2 := i*i;
yield(i.ToString+ ' squared = '+i2.ToString);
end;
end;
Tulajdonságok (properties)
Tulajdonságok (properties): Egy adattagot vagy metódust tudunk elérni és módosítani vele. Segítségével szabályozni tudjuk az adattag írását és olvasását. Pédául:
fMyInt: Integer;
property MyInt: Integer read fMyInt write fMyInt;
property MyString: Integer read GetString write SetString;
method GetString: String;
method SetString(aString: String);
Ahogyan a példából is látható read, elletve write kulcsszavak segítségével rendelünk hozzá egy műveletet egy tulajdonság olvasásához, illetve írásához. Ha valamelyik műveletet nem akarjuk megengedni, akkor hozzá tartozó kulcsszót nem írunk hozzá. Pl.:
property AlwaysTrue: Boolean read true; // Csak olvasható
read kulcsszó után egy kifejezés is állhat. Pl.:
property Prop1: Integer read 1 + 3;
Metódusok
Metódusok: az osztály eljárásai illetve, ha van visszatérési értékük, akkor függvényként is viselkedhetnek. Itt is lehet definiálni láthatóságokat, amik megegyeznek az osztály láthatóságaival. Van lehetőség túlterhelésre is, amit az "override" kulcsszóval jelezhetünk de nem kötelező. Szintaxis:
[class] method classname.methodname [parameters] [: result] ;
begin
[methodbody]
end;
Beágyazott metódusok (Nested Methods)
Az Oxygene lehetőséget ad egymásba ágyazott metódusok definiálására, ekkor a beágyazott metódus anonim metódushoz hasonlóan elérheti lokális változókat és paramétereket, de bármilyen változó megváltoztatás kiterjed a fő metódusra is.
Műveletek (operators)
Műveletek (operators)
Lehet saját műveleteket készíteni illetve a meglévőket felüldefiniálni.Pl.:
type
ComplexNumber = class
…
public
class operator Add(a: ComplexType; b: ComplexType): ComplexType;
class operator Add(a: ComplexType; b: Int32): ComplexType;
class operator Implicit(a: Int32): ComplexType;
end;
Abstract osztályok
Abstract Classes: egy vagy több absztrakt metódusa van. Nem lehet belőle konkrét példányt létrehozni.
Parital osztályok
Partial Classes: Ez egy olyan osztály, amit több különböző fájlban valósítunk meg.
type
MyClass = partial class
...
end
Sealed osztályok
Sealed Classes: nem lehet belőle származtatni.
type
MyClass = public sealed class
...
end;
Static osztályok
Static Classes: csak statikus tagjai vannak (amelyeket az osztály egy példánya nélül is lehet használni). Konkrét példányt nem is lehet belőle létrehozni.
type
MyClass = static class
class method Test;
end;
Global osztályok
Ezek olyan típusú osztályok, amik bárhonnan elérhetőek. Ennek engedélyezését külön be kell állítani fordítás előtt.
Interfészek
Az interfész az egy szerződés, ami előír bizonyos műveleteket és tulajdonságokat. Az a struktúra vagy osztály, ami megvalósítja ezt a szerződést meg kell valósítani a szerződésben leírt tuladonságokat. Egy osztály több interfészt is megvalósíthat.Ez a többszörös öröklődést pótolja valamilyen szinten. Az interfésznek nem lehet konkrát páldényát létrehozni.
interface
type
IMovement = public interface
method Walk;
method Run;
method Swim;
property NoOfLegs: Integer read write;
event Movement: EventHandler;
end;