Osztályok
A CorbaScript nyelvben lehetőség van script osztályok tervezésére és implementálására. A nyelv osztály fogalmán keresztül elérhetőek a klasszikus objektum-orientált programozás eszközei. Egy osztályon belül lehetőség van osztály- és példányváltozók, illetve osztály- és példánymetódusok definiálására. A polimorfizmus, a felüldefiniálás és a többszörös öröklés létezik a nyelvben, bár szintaktikailag nem támogatott.
Deklarálás
Egy osztály definiálásának szintaktikája a következő:
<class_declaration>::=
"class" <identifier> [ "(" <inherited_class_list> ")" ] "{" <statements>"}"
<inherited_class_list>::= <expression_list>
"class" <identifier> [ "(" <inherited_class_list> ")" ] "{" <statements>"}"
<inherited_class_list>::= <expression_list>
Egy osztálydeklaráció a class kulcsszó után egy azonosító megadásával kezdődik, majd vesszővel elválasztva az ősosztályok sorozata követi, végül pedig az osztály törzse. A törzs tartalmazhat metódusokat és attributumokat. A példányváltozók az első értékadással deklarálhatók. Természetesen a CorbaScript osztálykonstrukció a lehető legyegyszerűbb, mert a nyelv tervezői szerették volna a nyelv szintaktikáját a lehető legegyszerűbb formában hagyni.
Egy egyszerű osztály példa
A következő kis példa egy egyszerű osztály implementálását mutatja be, amely egy két dimenziós pontot reprezentál. A példán keresztül látható a példány- és osztályváltozók, illetve példány- és osztálymetodusok használata.
>>> class Point2D {
proc __Point2D__ ( self, x, y ){
selx.x = x
self.y = y
Point2D.nb_create_points = Point2D.nb_created_points + 1
}
proc show ( self ) {
println ("Point2D (x=",self.x, ", y", self.y, ")")
}
proc move (self, x, y){
self.x = self.x + x
self.y = self.y + y
}
proc how_many () {
println (nb_created_points, "Point2D példány elkészült." )
}
nb_created_points = 0
}
proc __Point2D__ ( self, x, y ){
selx.x = x
self.y = y
Point2D.nb_create_points = Point2D.nb_created_points + 1
}
proc show ( self ) {
println ("Point2D (x=",self.x, ", y", self.y, ")")
}
proc move (self, x, y){
self.x = self.x + x
self.y = self.y + y
}
proc how_many () {
println (nb_created_points, "Point2D példány elkészült." )
}
nb_created_points = 0
}
Példánymetódusok
CorbaScriptben minden példánymetódusnak az első argumentuma egy speciális, tetszőleges nevű a példányra mutató változó. Az interpreter gondoskodik róla, hogy ez a változó minden híváskor megkapja a megfelelő értéket. Ezen a változón keresztül tudjuk elérni és manipulálni a példány megfelelő változóit. Lehetőség van konstruktor jellegű metódus megadására, amely az osztály létrehozásakor fut le. Ennek speciális formátuma van, az osztály nevét "__" közé kell tenni.Példányváltozók
A példányváltozók automatikusan deklarálódnak az első értékadáskor. A példánymetódusok szabadon elérhetik ezket a változókat, a példány referencia változó segítségével.Osztálymetódusok
Ha üres paraméterlistával definiálunk egy metódust, akkor az osztályszintű lesz.Osztályváltozók
Ha prefix nélkül adunk értéket egy változónak, akkor az osztályváltozó lesz. Az osztályon belül bárhol hivatkozhatunk rá, de az osztályon kívül az osztálynevet mint prefixet ki kell tenni elé.Osztályok és példányok használata
A kövekező példa demonstrálja a Point2D osztály használatát:
>>> p = Point2D(1,1)
>>> p
< Point2D instance
x = 1
y = 1
>
>>> p.move(10,10)
>>> p.show()
Point2D( x=11, y=11 )
>>> p._type
< class Point2D {
proc __Point2D__ ( self, x, y );
proc show ( self );
proc move (self, x, y);
proc how_many ();
nb_created_points = 1;
}
>
>>> p
< Point2D instance
x = 1
y = 1
>
>>> p.move(10,10)
>>> p.show()
Point2D( x=11, y=11 )
>>> p._type
< class Point2D {
proc __Point2D__ ( self, x, y );
proc show ( self );
proc move (self, x, y);
proc how_many ();
nb_created_points = 1;
}
>
Egy egyszerű osztályöröklődés példa
CorbaScriptben lehetőség van egyszerű osztályöröklődés megvalósítására. A kövekező példában a Point3D osztályt fogjuk megvalósítani a Point2D osztály származtatásával.
A show és a move metódusokat felül fogjuk definiálni. Sajnos, a polimorfizmus nem működik, ha új paraméterrel bővítjük a metódusunkat. Az eljárásalias technikával van lehetőségünk a felüldefiniált metódus elérésére.
>>> class Point3D (Point2D) {
proc__Point3D__ (self, x ,y ,y){
self.__Point2D__(x, y)
self.z = z
}
proc show (self) { ... }
move2D = Point2D.move
proc move (self, p ){
self.move2D (p.x, p.y)
self.z = p.z
}
}
>>> p = Point3D (1,1,1)
proc__Point3D__ (self, x ,y ,y){
self.__Point2D__(x, y)
self.z = z
}
proc show (self) { ... }
move2D = Point2D.move
proc move (self, p ){
self.move2D (p.x, p.y)
self.z = p.z
}
}
>>> p = Point3D (1,1,1)
Többszörös öröklés példa
Van lehetőségünk többszörös öröklésre, mint ahogyan a következő példában láthatjuk.
>>> class ColoredPoint2D (Point2D) {
proc __ColoredPint2D__ (self, x, y, z, c) { ... }
proc show (self) { ... }
}
>>> class ColoredPoint3D (Point3D, ColoredPoint2D) {
proc __ColoredPoint3D__ (self, x, y, z, c) { ... }
proc show (self) { ... }
}
>>> p = ColoredPint3D (10,10,10,"green")
>>> p
< ColoredPoint3D instance
x = 10
y = 10
z = 10
c = "green"
>
A töbszörös öröklödésből következő anomáliák kezelésére a CorbaScript a deep-first algoritmust használja, azaz ha egy metódus több ősben is szerepel, akkor abból az lesz kiválásztva, amelyik előrébb szerepel az öröklési listában.
A metódus alias lehetőséget ad az egyébként elfedett metódusok használatára is.
proc __ColoredPint2D__ (self, x, y, z, c) { ... }
proc show (self) { ... }
}
>>> class ColoredPoint3D (Point3D, ColoredPoint2D) {
proc __ColoredPoint3D__ (self, x, y, z, c) { ... }
proc show (self) { ... }
}
>>> p = ColoredPint3D (10,10,10,"green")
>>> p
< ColoredPoint3D instance
x = 10
y = 10
z = 10
c = "green"
>
Osztályok és példány típusa
Az osztályok és a példányok mind CorbaScript objektumok, amelyeknek így használhatjuk a szabványos típusellenőrző műveleteit.