Gyakorlati alapok III.
A getter-setter függvények
Get it and set it!
A fejezet kis angol nyelvleckével kezdődik és aki ezt nem tudja lefordítani, az nagy bajban van programozás terén, mert ebben a szakmában a fordító-, és beszélőképes angol alapelvárás. (Ahogy egyik ismerősöm fogalmazott: az angol hiánya nem ciki, hanem a ciki alatt van.)
A fenti okoskodó nyelvlecke csak arra volt alkalmas, hogy megmutassa a getter-setter függvények szógyökeit, amelyek:
-
to get - megkapni, elérni, stb.
-
to set - beállítani, stb.
Ismételjük meg a bevezető fejezet legfontosabb gondolatát:
Az adatokat egy jól megtervezett osztályban csakis metódusokon keresztül érhetjük el!
Mit érünk ezzel? Az osztályadat saját privát hozzáférése miatt érintetlen marad,
ám a metódusokon keresztül mégis elérhetővé válik, sőt ezt a hozzáférést a
metódusokon keresztül sokféle módon szabályozni is tudjuk.
Pontosan a getter-setter metódusok lesznek az erre hivatott
kódegységek. Gyorsan nézzünk is meg működésükre egy alappéldát:
private int szam;
public int getSzam()
{
return this.szam;
}
public void setSzam(int szam)
{
this.szam = szam;
}
Az int szam változó private hozzáférés-módosítása miatt kívülről, azaz külső osztályból nem elérhető és az is marad. Ennek ellenére:
-
a getter függvényt (getSzam()) kívülről, azaz külső osztályból hívva elérhetjük a változó értékeit,
-
a setter függvény (setSzam()) segítségével közvetetten módosíthatjuk, szabályozhatjuk a változó értékeit.
Ezek miatt szoktak a getter függvényre accessor kifejezéssel (hozzáférő), a setter függvényre mutator kifejezéssel (megváltoztató) is hivatkozni.
Most illesszük a függvényeket egy Teszt osztályba, amely során deklarálunk 2 db különböző szignatúrájú konstruktor függvényt is.
Az int szam értéke legyen 2, de csak azért, hogy megváltoztatásának kísérletekor lássuk: ezt bizony nem tudjuk megtenni.
Ráadásként a setter függvényben (setSzam()) állítsunk be egy egyszerű szabályozást, legyen a számunkra megfelelő számtartomány 1 és 10 között, másként hibaüzenetet küldünk:
public class Teszt{
private int szam = 2;
public Teszt(){
}
public Teszt(int szam){
this.szam = szam;
}
public int getSzam(){
return this.szam;
}
public void setSzam(int szam){
if(szam > 10 || szam < 1){
System.out.println("Nem megfelelő számbevitel!");
}
this.szam = szam;
}
}
Ezután alkossunk a File - New - Class paranccsal a Teszt osztály mellé egy külön Main nevű osztályt, amelyben példányosítjuk a Teszt osztályt és elérhetjük metódusait:
Az 1. kísérletben a teszt.getSzam() metódussal lekérdezzük int szam értékét (2), valamint kísérlet teszünk átállítására (teszt.setSzam(11)), de mivel ez nem megengedett, (szabályozott) hibaüzenetet kapunk. A felhasznált konstruktor függvény a paraméterlista nélküli (Teszt()):
public class
Main {
public static void main(String[] args) {
Teszt teszt = new Teszt();
System.out.println(teszt.getSzam());
teszt.setSzam(11);
}
}
Végeredmény:
2
Nem megfelelő számbevitel!
A 2. kísérletben a felhasznált konstruktor függvény a paraméterlistás (Teszt(int szam)), amellyel 11-re állítottuk int szam értékét (Teszt(11)). Ezután a teszt2.getSzam() metódussal lekérdezzük int szam értékét (11), valamint kísérlet teszünk átállítására (teszt2.setSzam(11)), de mivel ez nem megengedett, (szabályozott) hibaüzenetet kapunk.
public class
Main {
public static void main(String[] args) {
Teszt teszt2 = new Teszt(11);
System.out.println(teszt2.getSzam());
teszt2.setSzam(11);
}
}
Végeredmény:
11
Nem megfelelő számbevitel!
Bármilyen kísérlet azonban kudarcot fog vallani, amellyel külső osztályból közvetlenül próbáljuk elérni private int szam értékét. Ez csakis akkor lesz lehetséges, ha hozzáférését public szóra módosítjuk:
public class Teszt{
public int szam = 2;
public Teszt(){
}
public Teszt(int szam){
this.szam = szam;
}
public int getSzam(){
return this.szam;
}
public void setSzam(int szam){
if(szam > 10 || szam < 1){
System.out.println("Nem megfelelő számbevitel!");
}
this.szam = szam;
}
}
public
class Main {
public static void main(String[] args) {
Teszt teszt3 = new Teszt();
System.out.println(teszt3.szam);
}
}
Végeredmény:
2
A getter-setter metódusok rendkívül fontosak az objektumorientált szemlélet érvényesítésében, főként az egységbezárás (encapsulation) implementálásakor. Ez olyannyira igaz, hogy egyszerű példakódok vagy oktatókódok kivételével nem fogunk olyan magasabb szintű Java-kóddal találkozni, amely ne tartalmazna getter-setter függvényeket.
Pénzes László