Hi! Ngayon ay pag-uusapan natin ang tungkol sa instanceof operator, isaalang-alang ang mga halimbawa kung paano ito ginagamit, at hawakan ang ilang aspeto ng kung paano ito gumagana:) Nakatagpo mo na ang operator na ito sa mga unang antas ng CodeGym. Naaalala mo ba kung bakit natin ito kailangan? Kung hindi, no worries. Sama-sama nating tandaan. Ang instanceof operator ay kinakailangan upang suriin kung ang isang bagay na isinangguni ng isang X variable ay nilikha batay sa ilang Y class. Parang simple lang. Bakit tayo bumalik sa paksang ito? Una sa lahat, dahil alam mo na ngayon ang mekanismo ng pamana ng Java at ang iba pang mga prinsipyo ng OOP. Magiging mas malinaw na ngayon ang instanceof operator at titingnan natin ang mga mas advanced na halimbawa kung paano ito ginagamit. Tara na!Marahil ay naaalala mo na ang instanceof operator ay nagbabalik ng true kung ang tseke ay nagsusuri sa true, o mali kung ang expression ay mali. Alinsunod dito, kadalasang nangyayari ito sa lahat ng uri ng mga kondisyong ekspresyon ( kung…iba pa ). Magsimula tayo sa ilang mas simpleng halimbawa:
public class Main {
public static void main(String[] args) {
Integer x = new Integer(22);
System.out.println(x instanceof Integer);
}
}
Ano sa palagay mo ang ipapakita sa console? Well, ito ay malinaw dito.:) Ang x object ay isang Integer, kaya ang resulta ay magiging totoo . Console output: True Subukan nating suriin kung ito ay String :
public class Main {
public static void main(String[] args) {
Integer x = new Integer(22);
System.out.println(x instanceof String); // Error!
}
}
Nagkaroon kami ng error. At bigyang-pansin: nabuo ng compiler ang error bago patakbuhin ang code! Agad nitong nakita na ang Integer at String ay hindi maaaring awtomatikong ma-convert sa isa't isa at hindi nauugnay sa pamamagitan ng mana. Dahil dito, ang isang bagay na Integer ay hindi nilikha batay sa String . Maginhawa ito at nakakatulong na maiwasan ang mga kakaibang error sa runtime, kaya tinulungan tayo ng compiler dito :) Ngayon subukan nating isaalang-alang ang mga halimbawa na mas mahirap. Dahil binanggit natin ang pamana, gawin natin ang sumusunod na maliit na sistema ng mga klase:
public class Animal {
}
public class Cat extends Animal {
}
public class MaineCoon extends Cat {
}
Alam na natin kung paano kumikilos ang instanceof kapag sinusuri natin kung ang isang object ay isang instance ng isang klase, ngunit ano ang mangyayari kung isasaalang-alang natin ang relasyon ng magulang-anak? Halimbawa, ano sa palagay mo ang idudulot ng mga expression na ito:
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);
}
}
Output: True False Ang pangunahing tanong na kailangang masagot ay eksakto kung paano binibigyang-kahulugan ng instanceof ang 'bagay na nilikha batay sa isang klase'? Ang ' cat instanceof Animal ' ay nagsusuri sa totoo , ngunit tiyak na makakahanap tayo ng mali sa mga salitang iyon. Bakit nilikha ang isang object ng Cat batay sa klase ng Animal ? Hindi ba ito nilikha batay sa sarili nitong klase lamang? Ang sagot ay sapat na simple, at maaaring naisip mo na ito. Tandaan ang pagkakasunud-sunod kung saan tinawag ang mga konstruktor at ang mga variable ay sinisimulan kapag lumilikha ng isang bagay. Natalakay na namin ang paksang ito sa artikulo tungkol sa mga tagapagtayo ng klase . Narito ang isang halimbawa mula sa araling iyon:
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");
}
}
At kung patakbuhin mo ito sa IDE, magiging ganito ang output ng console: Ang tagapagbuo ng klase ng base ng hayop ay tumatakbo Na-initialize na ba ang mga variable ng klase ng Animal? Kasalukuyang halaga ng static na variable na animalCount = 7700000 Kasalukuyang halaga ng utak sa klase ng Hayop = Paunang halaga ng utak sa klase ng Hayop Kasalukuyang halaga ng puso sa klase ng Hayop = Paunang halaga ng puso sa klase ng Hayop Mayroon na ang mga variable ng klase ng Cat na-initialize? Kasalukuyang halaga ng static variable catCount = 37 Animal base class constructor tapos na! Kasalukuyang halaga ng utak = Utak Kasalukuyang halaga puso = Puso Ang cat class constructor ay nagsimula na (Ang Animal constructor ay tapos na) Kasalukuyang halaga ng static variable catCount = 37 Kasalukuyang halaga ng buntot = Inisyal na halaga ng buntot sa Cat class Kasalukuyang halaga ng buntot = buntot Ngayon naaalala mo na ba?:) Ang constructor ng base class, kung mayroong base class, ay laging unang tinatawag kapag lumilikha ng object. Ang instanceof operator ay ginagabayan ng prinsipyong ito kapag sinusubukang tukuyin kung ang isang A object ay nilikha batay sa isang B class. Kung ang base class constructor ay tinawag, kung gayon ay walang duda. Sa pangalawang pagsusuri, ang lahat ay mas simple:
System.out.println(cat instanceof MaineCoon);
Hindi tinawag ang constructor ng MaineCoon noong nilikha ang object ng Cat , na may katuturan. Pagkatapos ng lahat, ang MaineCoon ay isang inapo ng Cat , hindi isang ninuno. At hindi ito isang template para sa Cat . Okay, sa tingin ko malinaw na tayo diyan. Ngunit ano ang mangyayari kung gagawin natin ito?:
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... mas mahirap na ngayon. Pag-usapan natin ito. Mayroon kaming variable ng Cat kung saan nagtalaga kami ng object ng MaineCoon . By the way, bakit gumagana pa yun? Kaya natin yan diba? Oo kaya natin. Pagkatapos ng lahat, ang bawat MaineCoon ay isang pusa. Kung hindi iyon lubos na malinaw, tandaan ang halimbawa ng pagpapalawak ng mga primitive na uri:
public class Main {
public static void main(String[] args) {
long x = 1024;
}
}
Ang numerong 1024 ay maikli : madali itong umaangkop sa isang mahabang variable, dahil may sapat na mga byte upang ma-accommodate ito (tandaan ang halimbawa sa mga manika?). Ang isang descendant object ay maaaring palaging italaga sa isang ancestor variable. Sa ngayon, tandaan lamang ito, at sa mga susunod na aralin ay susuriin natin kung paano ito gumagana. Kaya ano ang output ng aming halimbawa?
Ano ang susuriin ng halimbawa ? ang aming Cat variable o ang aming MaineCoon object? Ang sagot ay ang tanong na ito ay talagang simple. Kailangan mo lang basahin muli ang kahulugan ng operator: Ang instanceof operator ay kailangan upang suriin kung ang isang bagay na isinangguni ng isang X variable ay nilikha batay sa ilang Y class. Sinusuri ng instanceof operator ang pinagmulan ng isang bagay, hindi ang uri ng variable. Kaya, sa halimbawang ito, ang aming programa ay magpapakita ng totoo sa parehong mga kaso: mayroon kaming isang bagay na MaineCoon . Malinaw, nilikha ito batay sa klase ng MaineCoon , ngunit nilikha ito batay sa Catparent class din!
Marahil ay naaalala mo na ang instanceof operator ay nagbabalik ng true kung ang tseke ay nagsusuri sa true, o mali kung ang expression ay mali. Alinsunod dito, kadalasang nangyayari ito sa lahat ng uri ng mga kondisyong ekspresyon ( kung…iba pa ). Magsimula tayo sa ilang mas simpleng halimbawa:
GO TO FULL VERSION