Gyakorlati alapok III.
Öröklődés (inheritance)
Ha már elénk ugrott: származtassunk az Object osztályból!
A sok elmélet után nem maradt más hátra, mint elvégeznünk végre egy tisztes-őszes örökítést. Legyen kiindulási pontunk az
előző
fejezetben bemutatott Object, mint minden
API-osztály őse.
Ez azért előnyös, mert örökítés után rögtön hozzáférhetünk összes metódusához, illetve –amint a későbbiekben látni fogjuk-, a valamilyen módon nem korlátozott metódusokat felül is írhatjuk (overriding), ezáltal „testreszabhatjuk” a származtatott, más néven utódosztályt.
Az érthetőség kedvéért legyen ennek
osztályneve Subclass, referencianeve pedig
subclass.
A bevezető kódlépések természetesen sokfélék lehetnek, én új projektet, majd
benne új Subclass nevű osztályt hoztam létre az
opcionális main() főprogram automatikus
beillesztésével:
Az öröklődés mindig az extends kulcsszóval
történik, amelyet a következőképpen kell deklarálnunk:
public class Utodosztaly extends Ososztaly
A mostani esetben:
public class Subclass extends Object
Ezután az utódosztályt a
new paranccsal példányosítanunk kell:
Subclass
subclass = new Subclass();
A keletkezett subclass nevű objektum ismeri és
felhasználhatja minden, az ősosztályból származó, valamint valamilyen módon
nem korlátozott adatot és metódust. Ezt úgy tudjuk leellenőrizni, hogy az
objektumnév után írunk egy pontot (.), amelynek hatására egy listát kapunk az
elérhető adatokról és metódusokról (az Eclipse ezt built-in code
completion, beépített kódkiegészítésnek hívja). A fotó rossz minőségű,
mert a képernyőfotót kivételesen külsőleg kellett elkészítenem:
Észrevehetjük, hogy a Subclass utódosztályban is elérhetővé vált az Object osztály összes tulajdonsága.
Természetesen a subclass.toString() metódusa ugyanazt fogja művelni, amit az ős Object osztály toString() metódusa, hiszen az örökítés során egy az egyben lemásoltuk az ősosztály összes kódját:
public class
Subclass extends Object {
public static void main(String[] args) {
Subclass subclass = new Subclass();
System.out.println(subclass.toString());
}
}
Végeredmény:
java.lang.Object@15db9742
Azonban lehetőségünk van ennek
megváltoztatására és éppen ez az öröklődés lényege. Igényeink szerint írjuk át
(override) az utódosztály toString()
metódusát:
public class
Subclass extends Object {
public String toString() {
return "Hello world!";
}
public static void main(String[] args) {
Subclass subclass = new Subclass();
System.out.println(subclass.toString());
}
}
Végeredmény:
Hello world!
Az Eclipse még egy zöld háromszöggel figyelmeztet is erre overrides java.lang.Object.toString üzenettel:
A metódusok felüldefiniálása rohamütemben folytatódik! A következő lépésben nekiesünk az equals() függvénynek, amelynek eredeti kódja az ős Object osztályban így néz ki:
public boolean equals(Object obj) {
return (this == obj);
}
Ez egy teljesen általános egyenlőségvizsgálat (==) és garantáltan nem elég összetett objektumok esetében; szinte vonzza, hogy felül kell írnunk. Ezt erősíti az alábbi kód is, hiszen 2, azonosnak tűnő objektum (subclass1 és subclass2) esetén false a végeredmény.
public class
Subclass extends Object {
public static void main(String[] args) {
Subclass subclass1 = new Subclass();
Subclass subclass2 = new Subclass();
System.out.println(subclass1.equals(subclass2));
}
}
Végeredmény:
false
Ugye látjuk, hogy subclass1 és subclass2 objektumok létrehozásakor a Subclass utódosztályból 2 különböző objektum keletkezik?
Az equals() függvény használata azonban becsapós, hiszen láthatóan nem tettünk többet, mint ezt (System.out.println(subclass1 == subclass2)):
public class
Subclass extends Object {
public static void main(String[] args) {
Subclass subclass1 = new Subclass();
Subclass subclass2 = new Subclass();
System.out.println(subclass1 == subclass2);
}
}
Végeredmény:
false
Az equals() függvény matematikailag és programozás-technikailag pontos használatához bele kéne merülnünk a már említett Mikor egyenlő az egyenlő avagy az equals() függvény című fejezetbe. Ezt most hanyagoljuk, másként rém bonyolulttá tesszük példakódunkat. Helyette tegyük meg a következő, egyszerűsített megállapítást (ami nyilvánvalóan alapértelmezésben nem igaz):
Legyen a 2 objektum akkor egyenlő, ha azonos osztályból származnak!
Tehát ezen szabályunkat kell implementálni, még pedig felülírva az utódosztály equals() metódusát:
public class
Subclass extends Object {
public boolean equals(Object obj) {
return (this.getClass() == obj.getClass());
}
public static void main(String[] args) {
Subclass subclass1 = new Subclass();
Subclass subclass2 = new Subclass();
System.out.println(subclass1.equals(subclass2));
}
}
Végeredmény:
true
Természetesen tetszőleges mennyiségben egészíthetjük ki az utódosztályt további adatokkal és metódusokkal. Alább csak egy void típusú üdvözlőmetódust illesztünk hozzá:
public class
Subclass extends Object {
public void welcome() {
System.out.println("Hello world!");
}
public static void main(String[] args) {
Subclass subclass = new Subclass();
subclass.welcome();
}
}
Végeredmény:
Hello world!
Összegzésképpen nézzük meg többszörösen felülírt és kiegészített utódosztályunkat:
public class
Subclass extends Object {
public String toString() {
return "Hello world a toString()-ben!";
}
public boolean equals(Object obj) {
return (this.getClass() == obj.getClass());
}
public void welcome() {
System.out.println("Hello world a welcome()-ban!");
}
public static void main(String[] args) {
Subclass subclass1 = new Subclass();
System.out.println(subclass1.toString());
Subclass subclass2 = new Subclass();
System.out.println(subclass1.equals(subclass2));
subclass1.welcome();
}
}
Végeredmény:
Hello world a toString()-ben!
true
Hello world a welcome()-ban!
Pénzes László