Szia! Ma az instanceof operátorról fogunk beszélni , megfontolunk példákat a használatára, és érintünk működésének néhány aspektusát:) Már találkoztál ezzel az operátorral a CodeGym korai szintjein. Emlékszel, miért van szükségünk rá? Ha nem, semmi gond. Emlékezzünk együtt. Az instanceof operátor annak ellenőrzéséhez szükséges, hogy egy X változó által hivatkozott objektum létrejött-e valamilyen Y osztály alapján . Ez egyszerűen hangzik. Miért tértünk vissza ehhez a témához? Először is azért, mert most már jól ismeri a Java öröklődési mechanizmusát és az OOP többi alapelvét. Az instanceof operátor most sokkal világosabb lesz, és részletesebb példákat fogunk látni a használatára. Gyerünk!Valószínűleg emlékszel arra, hogy az instanceof operátor igazat ad vissza , ha az ellenőrzés értéke igaz, vagy false-t , ha a kifejezés hamis. Ennek megfelelően általában mindenféle feltételes kifejezésben előfordul ( if…else ). Kezdjük néhány egyszerűbb példával:
public class Main {
public static void main(String[] args) {
Integer x = new Integer(22);
System.out.println(x instanceof Integer);
}
}
Szerinted mi fog megjelenni a konzolon? Nos, ez itt nyilvánvaló.:) Az x objektum egy egész szám, így az eredmény igaz lesz . A konzol kimenete: True Próbáljuk meg ellenőrizni, hogy ez egy karakterlánc :
public class Main {
public static void main(String[] args) {
Integer x = new Integer(22);
System.out.println(x instanceof String); // Error!
}
}
Hibát kaptunk. És figyelj: a fordító generálta a hibát a kód futtatása előtt! Azonnal látta, hogy az Integer és a String nem konvertálható automatikusan egymásba, és nem kapcsolódnak egymáshoz öröklődés útján. Következésképpen egy Integer objektum nem jön létre a String alapján . Ez kényelmes, és segít elkerülni a furcsa futásidejű hibákat, ezért a fordító itt segített nekünk :) Most próbáljunk meg olyan példákat venni, amelyek nehezebbek. Mivel az öröklődést említettük, dolgozzunk a következő kis osztályrendszerrel:
public class Animal {
}
public class Cat extends Animal {
}
public class MaineCoon extends Cat {
}
Már tudjuk, hogyan viselkedik az instanceof , amikor ellenőrizzük, hogy egy objektum egy osztály példánya-e, de mi történik, ha figyelembe vesszük a szülő-gyermek kapcsolatot? Például Ön szerint mit fognak eredményezni ezek a kifejezések:
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
System.out.println(cat instanceof Animal);
System.out.println(cat instanceof MaineCoon);
}
}
Kimenet: Igaz Hamis A fő kérdés, amit meg kell válaszolni, hogy az instanceof pontosan hogyan értelmezi az „egy osztály alapján létrehozott objektumot”? A ' cat instanceof Animal ' értéke igaz , de biztosan találhatunk hibát ebben a megfogalmazásban. Miért jön létre egy Cat objektum az Animal osztály alapján ? Csak nem a saját osztálya alapján jött létre? A válasz elég egyszerű, és lehet, hogy már gondoltál rá. Emlékezzen a konstruktorok meghívásának és a változók inicializálásának sorrendjére az objektum létrehozásakor. Az osztálykonstruktorokról szóló cikkben már foglalkoztunk ezzel a témával . Íme egy példa a leckéből:
public class Animal {
String brain = "Initial value of brain in the Animal class";
String heart = "Initial value of heart in the Animal class";
public static int animalCount = 7700000;
public Animal(String brain, String heart) {
System.out.println("Animal base class constructor is running");
System.out.println("Have the variables of the Animal class already been initialized?");
System.out.println("Current value of static variable animalCount = " + animalCount);
System.out.println("Current value of brain in the Animal class = " + this.brain);
System.out.println("Current value of heart in the Animal class = " + this.heart);
System.out.println("Have the variables of the Cat class already been initialized?");
System.out.println("Current value of static variable catCount = " + Cat.catCount);
this.brain = brain;
this.heart = heart;
System.out.println("Animal base class constructor is done!");
System.out.println("Current value of brain = " + this.brain);
System.out.println("Current value of heart = " + this.heart);
}
}
public class Cat extends Animal {
String tail = "Initial value of tail in the Cat class";
static int catCount = 37;
public Cat(String brain, String heart, String tail) {
super(brain, heart);
System.out.println("The Cat class constructor has started (The Animal constructor already finished)");
System.out.println("Current value of static variable catCount = " + catCount);
System.out.println("Current value of tail = " + this.tail);
this.tail = tail;
System.out.println("Current value of tail = " + this.tail);
}
public static void main(String[] args) {
Cat cat = new Cat("Brain", "Heart", "Tail");
}
}
És ha az IDE-ben futtatod, a konzol kimenete így fog kinézni: Animal base class konstruktor fut. Az Animal osztály változói már inicializálva vannak? A statikus változó aktuális értéke animalCount = 7700000 Az agy aktuális értéke az Animal osztályban = Az agy kezdeti értéke az Állatok osztályban A szív aktuális értéke az Állatok osztályban = A szív kezdeti értéke az Állatok osztályban A Cat osztály változói már megvannak. inicializálva lett? A statikus változó aktuális értéke catCount = 37 Az állati alaposztály konstruktor kész! Az agy aktuális értéke = Agy Aktuális érték szív = Szív A macska osztály konstruktor elindult (Az állat konstruktor már befejezte) A statikus változó aktuális értéke catCount = 37 A farok aktuális értéke = A farok kezdeti értéke a Cat osztályban A farok jelenlegi értéke = Farok Most emlékszel?:) Az alaposztály konstruktora, ha van alaposztály, mindig először hívódik meg objektum létrehozásakor. Az instanceof operátort ez az elv vezérli, amikor megpróbálja meghatározni, hogy egy A objektum egy B osztály alapján jött-e létre . Ha az alaposztály-konstruktort meghívjuk, akkor nem lehet kétséges. A második ellenőrzéssel minden egyszerűbb:
System.out.println(cat instanceof MaineCoon);
A MaineCoon konstruktort nem hívták meg a Cat objektum létrehozásakor, aminek van értelme. Végül is MaineCoon Cat leszármazottja , nem pedig őse. És ez nem a Cat számára készült sablon . Oké, azt hiszem, ezzel tisztában vagyunk. De mi történik, ha ezt tesszük?:
public class Main {
public static void main(String[] args) {
Cat cat = new MaineCoon();
System.out.println(cat instanceof Cat);
System.out.println(cat instanceof MaineCoon);
}
}
Hmm... ez most nehezebb. Beszéljük meg. Van egy Cat változónk, amelyhez egy MaineCoon objektumot rendeltünk . Egyébként ez miért működik? Megtehetjük, igaz? Igen. Végül is minden MaineCoon egy macska. Ha ez nem teljesen világos, emlékezzünk a primitív típusok kiszélesedésének példájára:
public class Main {
public static void main(String[] args) {
long x = 1024;
}
}
Az 1024- es szám rövid : könnyen belefér egy hosszú változóba, mivel elegendő bájt van hozzá (emlékszel a babákkal kapcsolatos példára?) . Egy leszármazott objektum mindig hozzárendelhető egy ősváltozóhoz. Egyelőre csak emlékezzen erre, és a következő leckékben elemezzük, hogyan működik. Tehát mit eredményez a példánk?
Mi fogja ellenőrizni a példányt ? a Cat változónk vagy a MaineCoon objektumunk? A válasz az, hogy ez a kérdés valójában egyszerű. Csak újra kell olvasni az operátor definícióját: Az instanceof operátorra azért van szükség, hogy ellenőrizzük, hogy egy X változó által hivatkozott objektum létrejött-e valamilyen Y osztály alapján . Az instanceof operátor az objektum eredetét teszteli, nem a változó típusát. Így ebben a példában a programunk mindkét esetben igazat fog megjeleníteni : van egy MaineCoon objektumunk. Nyilvánvalóan a MaineCoon osztály alapján készült , de a Cat alapján készültszülői osztály is!
Valószínűleg emlékszel arra, hogy az instanceof operátor igazat ad vissza , ha az ellenőrzés értéke igaz, vagy false-t , ha a kifejezés hamis. Ennek megfelelően általában mindenféle feltételes kifejezésben előfordul ( if…else ). Kezdjük néhány egyszerűbb példával:
GO TO FULL VERSION