A Chrome programozási nyelv

Objektum-orientált programozás



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. A Chrome 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;

Események (events)

Események (events): A Chrome 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 kíírva:

type TMyClass = class(…) private fMyEvent: EventHandler; public event MyEvent: EventHandler delegate fMyEvent; end;

Adatmezők (fields)

Adatmezők (fields): Olyan változók, amikat 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: A Chrome 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;

Bejárók (itarators)

Bejárók (itarators): 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 intervalumon):

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 adatagot vagy metódusz 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);

Metódusok

Metódusok: az össztá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 jellezhetünk de nem kötelező. Szintaxis:

[class] method classname.methodname [parameters] [: result] ; begin [methodbody] end;

Műveletek (operators)

Műveletek (operators): Tehet saját műveleteket készíteni illetve a meglévőket felüldefiniálni.

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;