Property és indexelés
Bevezetés
A ’Property’ egy komponens névvel ellátott értéke. Például, egy gomb rendelkezhet a „text” property-vel, ami a megjelenítendő szövegre utal. A propertyhez hozzáférő metódusoknak két fajtája van a getter és a setter, ezek a property-k általában csak olvashatóak vagy csak írhatóak. Ha mindkét metódus implementálva van, akkor a property írható és olvasható. A property olvasó és módosító metódusok specifikációja erősen programnyelv függő. Pl. Visual Basic 6.0-ban a hozzáférő metódusokat a Set, Get és Let metódusok alkotják
Properties – Smart Fields
A J# nyelvben setter és getter metódusok önálló metódusokként vannak specifikálva, ami azt jelenti, hogy osztályok vagy interfészek tagjai lehetnek. Használatuk során egy private hozzáférésű változó értékét változtathatják meg ,vagy adhatják vissza.
Egy property deklarálásának szabályai:- A getter és setter metódusok hozzáférhetőségének ugyanolyannak kell lennie
- A property típusa meg kell egyezzen a getter metódus visszatérési értékének típusával, és a setter metódus utolsó paraméterének típusával
- A metódusokat egy speciális naming patternnel kell ellátni(@property)
A metódusok helyes deklarációjához meg kell adnunk a /** @property*/ tagot. A metódusok neveinek a set_ vagy get_ előtaggal kell kezdődniük, melyet a property neve kell, hogy kövessen.
public class button
{
private String s;
/** @property */
public void set_text(String val) { s = val; }
/** @property */
public String get_text() { return s; }
}
A J# nyelv nem tesz semmilyen különösebb megkötést a metódusok hozzáférésével kapcsolatban. A J# a konvencionális metódus hívás szintaktikáját követi, ami teljesen megfelel a Java nyelvben használt szintaxisnak.
Indexelők – Smart Arrays
Egy indexelő (vagy indexelt property) a setter metódustól eltérően kéri a bemenő paramétereket. A különböző nyelvek speciális szintaxis definiálásával valósítják meg az indexelők használatát, ami eléggé hasonlít a tömbök indexeléséhez. A J# minden típushoz egy indexelt property-t ad. Ezek használatát a System.Reflection.DefaultMember attribútum megadásával érhetjük el. Nézzük meg a TextFile osztály implementációját, ami tartalmaz egy indexelt property-t.
file[pos]
segítségével karakterket olvashatunk és írhatunk. Amikor az index megjelenik a kifejezés bal oldalán, akkor a karakter a file megfelelő pozíciójára iródik.
file[pos] = value;
Amikor az index a kifejezés jobb oldalán jelenik meg, akkor a file megfelelő pozícióján lévő érték kerül kiolvasásra.
value = file[pos];
Íme a TextFile osztály:
import java.io.*;
/** @attribute System.Reflection.DefaultMember("at") */
public class TextFile
{
private RandomAccessFile _raf;
public TextFile(String filename, String mode)
{
try {
_raf = new RandomAccessFile(filename, mode);
} catch (Exception e) { ; }
}
/** @property */
public int get_at(int pos)
{
int ch = -1;
try {
_raf.seek(pos);
ch = _raf.read();
} catch (Exception e) { ; }
return ch;
}
/** @property */
public void set_at(int pos, int ch)
{
try {
_raf.seek(pos);
_raf.write(ch);
} catch (Exception e) { ; }
}
}
Ahogy azt már említettük a különböző programozási nyelvek speciális szintaxist biztosítnak a property-k támogatására. Íme egy C# példa, amely egy ’sample.tx’ file tartalmát a konsolera írja:
public class app
{
public static void Main(string [] args)
{
TextFile f = new TextFile("sample.txt", "r");
int c = -1;
int i = 0;
while ((c = f[i++]) != -1)
{
System.Console.Write((char) c);
}
}
}
A szinatxis teljesen természetes: egy szöveg file absztrakt megfelelője karakterek egy tömbje. Az egyetlen művelet, amire szükségünk van, az indexelés.
Ahhoz , hogy az indexelést működés közben láthassuk, nézzünk egy programot (ismét C#), amely két TextFile objektumot feleltet meg két szöveges file-nak.
TextFile source = new TextFile("sample.txt", "r");
TextFile dest = new TextFile("example.txt", "rw");
char ch;
int i, j;
a ch a forrás file j-edik karakterének felel meg.
ch = (char) source[j];
Azok a nyelvek, melyek nem adnak meg semmi különösebb szintaxist az indexelt proerty-khez való hozzáféréshez(mint pl. J#), a feladatot így is megvalósíthatják:
ch = (char) source.get_at(j); // J# példa
Az indexelés a kifejezés mindkét oldalán megjelenhet, hogy az egyik fileból kiolvasott adatot egy másik fileba írjuk:
dest[i] = source[j]; // C# példa
Az fent említett kifejezés ekvivalens az alábbival:
dest.set_at(i, source.get_at(j)); // J# példa