Paggalugad ng mga tanong at sagot mula sa isang job interview para sa isang Java developer position. Bahagi 11

Hi! Kahit na ang pinakamabilis na barko ay aanod na lang sa alon kung wala itong landas. Kung binabasa mo ang artikulong ito ngayon, tiyak na mayroon kang layunin. Ang pangunahing bagay ay hindi umalis sa kurso at sa halip ay pumunta sa lahat upang maging isang developer ng Java. Ngayon gusto kong ipagpatuloy ang aking pagsusuri ng mga tanong para sa mga developer ng Java upang makatulong na punan ang ilan sa iyong mga gaps sa teorya.

97. Mayroon bang anumang mga patakaran na nalalapat kapag nag-o-override sa katumbas ()?

Kapag na-override ang equals() na pamamaraan, dapat kang sumunod sa mga sumusunod na panuntunan:

• reflexivity — para sa anumang value x , x.equals(x) ay dapat palaging bumalik ng true (kung saan x != null ).

• symmetry — para sa anumang mga value na x at y , x.equals(y) ay dapat magbalik ng true lamang kung ang y.equals(x) ay nagbabalik ng true .

• transitivity — para sa anumang mga value na x , y at z , kung ang x.equals(y) ay nagbabalik ng true at ang y.equals(z) ay nagbabalik din ng true , kung gayon ang x.equals(z) ay dapat magbalik ng true .

• pagkakapare-pareho — para sa anumang mga value na x at y , ang paulit-ulit na pagtawag sa x.equals(y) ay palaging magbabalik ng parehong halaga hangga't ang mga field na ginamit upang ihambing ang dalawang bagay ay hindi nagbabago sa pagitan ng bawat tawag.

• null comparison — para sa anumang value x , ang pagtawag sa x.equals(null) ay dapat magbalik ng false .

98. Ano ang mangyayari kung hindi mo i-override ang equals() at hashCode()?

Sa kasong ito, ang hashCode() ay magbabalik ng isang numerong nabuo batay sa address ng memory cell kung saan nakaimbak ang bagay. Sa madaling salita, kapag ang orihinal na hashCode() na pamamaraan ay tinawag sa dalawang bagay na may eksaktong parehong mga patlang, ang resulta ay magkakaiba (dahil ang mga ito ay nakaimbak sa magkaibang lokasyon ng memorya). Ang orihinal na equals() na pamamaraan ay naghahambing ng mga sanggunian, ibig sabihin, ito ay nagpapahiwatig kung ang mga sanggunian ay tumuturo sa parehong bagay. Sa madaling salita, ang paghahambing ay gumagamit ng == operator, at ito ay palaging magbabalik ng false para sa iba't ibang mga bagay, kahit na ang kanilang mga patlang ay magkapareho. ang true ay ibinalik lamang kapag inihahambing ang mga sanggunian sa parehong bagay. Minsan makatuwiran na huwag i-override ang mga pamamaraang ito. Halimbawa, gusto mong maging natatangi ang lahat ng object ng isang partikular na klase — ang pag-override sa mga paraang ito ay maaari lamang masira ang umiiral na garantiya ng mga natatanging hash code. Ang mahalagang bagay ay upang maunawaan ang mga nuances ng mga pamamaraang ito, kung na-override man o hindi, at gamitin ang alinmang diskarte na kailangan ng sitwasyon.

99. Bakit natutugunan lamang ang kinakailangan ng symmetry kung ang x.equals(y) ay nagbabalik ng totoo?

Medyo kakaiba ang tanong na ito. Kung ang object A ay katumbas ng object B, kung gayon ang object B ay katumbas ng object A. Kung ang B ay hindi katumbas ng object A, kung gayon paano magiging posible ang reverse? Common sense ito.

100. Ano ang banggaan ng HashCode? Paano mo ito haharapin?

Ang isang banggaan ng HashCode ay nangyayari kapag ang dalawang magkaibang bagay ay may parehong HashCode . Paano ito posible? Well, ang hash code ay namamapa sa isang Integer, na may saklaw mula -2147483648 hanggang 2147483647. Ibig sabihin, maaari itong isa sa humigit-kumulang 4 na bilyong magkakaibang integer. Malaki ang saklaw na ito ngunit hindi walang hanggan. Nangangahulugan iyon na may mga sitwasyon kapag ang dalawang ganap na magkaibang mga bagay ay maaaring magkaroon ng parehong hash code. Ito ay lubos na hindi malamang, ngunit ito ay posible. Ang isang hindi maayos na ipinatupad na hash function ay maaaring gawing mas madalas ang magkaparehong hash code sa pamamagitan ng pagbabalik ng mga numero sa isang maliit na hanay, kaya tumataas ang pagkakataon ng mga banggaan. Upang mabawasan ang mga banggaan, kailangan mong magkaroon ng isang mahusay na pagpapatupad ng pamamaraan ng HashCode na pantay na nagkakalat ng mga halaga at nagpapaliit sa pagkakataon ng mga paulit-ulit na halaga.

101. Ano ang mangyayari kung magbago ang halaga ng isang elementong kalahok sa kontrata ng hashCode?

Kung nagbabago ang isang elementong kasangkot sa pagkalkula ng hash code, dapat magbago ang hash code ng object (kung maganda ang hash function). Iyon ang dahilan kung bakit dapat kang gumamit ng mga hindi nababagong bagay bilang mga susi sa isang HashMap , dahil hindi na mababago ang kanilang panloob na estado (mga patlang) pagkatapos ng paglikha. At sumusunod na ang kanilang hash code ay nagbabago pagkatapos ng paglikha. Kung gagamit ka ng nababagong bagay bilang isang susi, kapag nagbago ang mga field ng object, magbabago ang hash code nito, at maaaring mawala sa iyo ang katumbas na key-value pair sa HashMap . Pagkatapos ng lahat, ito ay maiimbak sa bucket na nauugnay sa orihinal na hash code, ngunit pagkatapos magbago ang object, hahanapin mo ito sa ibang bucket.

102. Sumulat ng equals() at hashCode() na mga pamamaraan para sa klase ng Mag-aaral na mayroong String name at int age na mga field.

public class Student {
int age;
String name;

 @Override
 public boolean equals(final Object o) {
   if (this == o) {
     return true;
   }
   if (o == null || this.getClass() != o.getClass()) {
     return false;
   }

   final Student student = (Student) o;

   if (this.age != student.age) {
     return false;
   }
   return this.name != null ? this.name.equals(student.name) : student.name == null;
 }

 @Override
 public int hashCode() {
   int result = this.age;
   result = 31 * result + (this.name != null ? this.name.hashCode() : 0);
   return result;
 }
}

katumbas ng():

• Una, direktang inihahambing namin ang mga sanggunian, dahil kung ang mga sanggunian ay tumuturo sa parehong bagay, ano ang punto sa patuloy na pagsusuri para sa pagkakapantay-pantay? Alam na natin na magiging totoo ang magiging resulta .

• Sinusuri namin ang null at kung ang mga uri ng klase ay pareho dahil kung ang parameter ay null o ng ibang uri, kung gayon ang mga bagay ay hindi maaaring pantay, at ang resulta ay dapat na false .

• Inihagis namin ang parameter sa parehong uri (pagkatapos ng lahat, paano kung ito ay isang bagay ng uri ng magulang).

• Inihambing namin ang mga primitive na patlang (isang paghahambing gamit ang =! ay sapat na). Kung hindi sila pantay, ibinabalik namin ang false .

• Sinusuri namin ang non-primitive na patlang upang makita kung ito ay null at gamit ang katumbas na pamamaraan (ang String class ay nag-o-override sa pamamaraan, kaya gagawin nito nang tama ang paghahambing). Kung ang parehong mga field ay null, o katumbas ay nagbabalik ng true , hihinto kami sa pagsuri, at ang pamamaraan ay nagbabalik ng true .

hashCode() :

• Itinakda namin ang paunang halaga ng hash code na katumbas ng halaga ng field ng edad ng object .

• I-multiply namin ang kasalukuyang hash code sa 31 (para sa mas malaking spread sa mga value) at pagkatapos ay idagdag ang hash code ng non-primitive String field (kung hindi ito null).

• Ibinabalik namin ang resulta.

• Ang pag-override sa pamamaraan sa ganitong paraan ay nangangahulugan na ang mga bagay na may parehong pangalan at mga int na halaga ay palaging magbabalik ng parehong hash code.

103. Ano ang pagkakaiba sa pagitan ng paggamit ng "if (obj instanceof Student)" at "if (getClass() == obj.getClass())"?

Tingnan natin kung ano ang ginagawa ng bawat expression:

• instanceof sinusuri kung ang object reference sa kaliwang bahagi ay isang instance ng uri sa kanang bahagi o isa sa mga subtype nito.

• Sinusuri ng "getClass() == ..." kung pareho ang mga uri.

Sa madaling salita, ang getClass() ay nagbabalik ng partikular na pagkakakilanlan ng klase, ngunit ang instanceof ay nagbabalik ng totoo kahit na ang object ay isang subtype lamang, na maaaring magbigay sa amin ng higit na kakayahang umangkop kapag gumagamit ng polymorphism. Ang parehong mga diskarte ay nangangako kung tiyak mong nauunawaan kung paano gumagana ang mga ito at ilalapat ang mga ito sa mga tamang lugar.

104. Magbigay ng maikling paglalarawan ng clone() na pamamaraan.

Ang clone() na pamamaraan ay kabilang sa klase ng Object . Ang layunin nito ay lumikha at magbalik ng isang clone (kopya) ng kasalukuyang bagay. Para magamit ang paraang ito, kailangan mong ipatupad ang Cloneable marker interface:

Student implements Cloneable

At i-override ang clone() na pamamaraan mismo:

@Override
protected Object clone() throws CloneNotSupportedException {
 return super.clone();
}

Pagkatapos ng lahat, ito ay protektado sa klase ng Bagay , ibig sabihin, makikita lamang ito sa loob ng klase ng Mag-aaral at hindi makikita ng mga panlabas na klase.

105. Anong mga espesyal na pagsasaalang-alang ang kailangan mong tandaan tungkol sa clone() na pamamaraan at mga reference na variable sa isang bagay?

Kapag ang mga bagay ay na-clone, ang mga primitive na halaga lamang at ang halaga ng mga sanggunian ng bagay ang kinokopya. Nangangahulugan ito na kung ang isang bagay ay may isang patlang na tumutukoy sa isa pang bagay, kung gayon ang sanggunian lamang ang mai-clone - ang iba pang na-refer na bagay na ito ay hindi mai-clone. Ito ang tinatawag na shallow copy. Kaya, paano kung kailangan mo ng isang ganap na kopya, kung saan ang bawat nested na bagay ay na-clone? Paano mo matitiyak na ang mga ito ay hindi lamang mga kopya ng mga sanggunian, ngunit sa halip ay ganap na mga kopya ng mga natatanging bagay na sumasakop sa natatanging mga address ng memorya sa heap? Sa totoo lang, ang lahat ng ito ay medyo simple — para sa bawat klase na isinangguni sa loob, kailangan mong i-override ang clone() na paraan at idagdag ang Cloneable marker interface. Kapag nagawa mo na ito, hindi kokopyahin ng clone operation ang mga reference sa mga umiiral nang object, ngunit sa halip ay kokopyahin ang mga reference na object, dahil may kakayahan na rin silang kopyahin ang kanilang mga sarili.

Mga pagbubukod

106. Ano ang pagkakaiba sa pagitan ng error at exception?

Ang mga pagbubukod, pati na rin ang mga error, ay mga subclass ng Throwable . Gayunpaman, mayroon silang kanilang mga pagkakaiba. Ang error ay nagpapahiwatig ng isang problema na pangunahing nangyayari dahil sa kakulangan ng mga mapagkukunan ng system. At hindi dapat makita ng aming application ang mga ganitong uri ng problema. Kasama sa mga halimbawa ng mga error na ito ang isang system crash at out-of-memory error. Ang mga error ay kadalasang nangyayari sa runtime, dahil ang mga ito ay hindi naka-check. Ang mga pagbubukod ay mga problema na maaaring mangyari sa runtime at sa oras ng pag-compile. Karaniwang lumalabas ang mga problemang ito sa code na isinusulat namin bilang mga developer. Ibig sabihin, ang mga pagbubukod na ito ay mas mahuhulaan at mas nakadepende sa amin. Sa kabaligtaran, ang mga error ay mas random at mas independyente sa atin. Sa halip, umaasa sila sa mga problema sa system kung saan tumatakbo ang aming application.

107. Ano ang pagkakaiba ng checked, unchecked, exception, throw, at throws?

Gaya ng sinabi ko kanina, ang exception ay isang runtime o compile-time na error na nangyayari sa code na isinulat ng developer (dahil sa ilang abnormal na sitwasyon). Ang naka-check ay ang tinatawag naming mga exception na dapat palaging pangasiwaan ng isang paraan sa pamamagitan ng paggamit ng try-catch na mekanismo o i-rethrow sa paraan ng pagtawag. Ang keyword na throws ay ginagamit sa isang header ng pamamaraan upang isaad ang mga pagbubukod na maaaring itapon ng pamamaraan. Sa madaling salita, ito ay nagbibigay sa amin ng isang mekanismo para sa paghagis ng mga pagbubukod sa paraan ng pagtawag. Ang mga hindi na-check na exception ay hindi kailangang pangasiwaan. May posibilidad silang hindi gaanong mahuhulaan at mas malamang. Sabi nga, kakayanin mo sila kung gusto mo. Gumagamit kami ng throw kapag manu-manong naghagis ng exception, halimbawa:

throw new Exception();

108. Ano ang exception hierarchy?

Napakalawak ng exception hierarchy. Napakaraming sapat na ilarawan dito. Kaya, sa halip ay isasaalang-alang lamang natin ang mga pangunahing sangay nito: Dito, sa pinakatuktok ng hierarchy, makikita natin ang Throwable class, na siyang pangkalahatang ninuno ng exception hierarchy at nahahati naman sa:

• Mga error — kritikal, hindi nasuri na mga problema.
• Mga pagbubukod — mga pagbubukod na maaaring suriin.

Ang mga pagbubukod ay nahahati sa iba't ibang hindi naka-check na runtime na mga pagbubukod at iba't ibang mga nasuri na mga pagbubukod.

109. Ano ang mga naka-check at hindi naka-check na mga exception?

Gaya ng sinabi ko kanina:

• Ang mga naka-check na exception ay mga exception na kailangan mong pangasiwaan. Iyon ay, dapat mong hawakan ang mga ito sa isang try-catch block o itapon ang mga ito sa paraan sa itaas. Upang gawin ito, pagkatapos ilista ang mga argumento ng pamamaraan sa lagda ng pamamaraan, gumamit ng mga throws <type ng pagbubukod> upang ipahiwatig na maaaring itapon ng pamamaraan ang pagbubukod na iyon. Ito ay medyo tulad ng isang babala, na inilalagay ang paraan ng pagtawag sa abiso na dapat itong tanggapin ang responsibilidad para sa paghawak sa pagbubukod na iyon.

• Ang mga hindi na-check na exception ay hindi kailangang pangasiwaan, dahil hindi sila sinusuri sa oras ng pag-compile at kadalasan ay mas hindi nahuhulaan. Ang kanilang pangunahing pagkakaiba sa mga naka-check na exception ay ang paghawak sa mga ito sa pamamagitan ng paggamit ng try-catch block o sa pamamagitan ng rethrowing ay opsyonal sa halip na sapilitan.

101. Sumulat ng isang halimbawa kung saan gumagamit ka ng try-catch block upang mahuli at mahawakan ang isang exception.

try{                                                 // Start of the try-catch block
 throw new Exception();                             // Manually throw an exception
} catch (Exception e) {                              // Exceptions of this type and its subtypes will be caught
 System.out.println("Oops! Something went wrong =("); // Display the exception
}

102. Sumulat ng isang halimbawa kung saan mo hinuhuli at pinangangasiwaan ang iyong sariling mga custom na exception.

Una, isulat natin ang sarili nating klase ng exception na nagmamana ng Exception at i-override ang constructor nito na kumukuha ng error message bilang argumento:

public class CustomException extends Exception {

 public CustomException(final String message) {
   super(message);
 }
}

Susunod, manu-mano naming itatapon ang isa at sasaluhin ito tulad ng ginawa namin sa halimbawa para sa nakaraang tanong:

try{
 throw new CustomException("Oops! Something went wrong =(");
} catch (CustomException e) {
 System.out.println(e.getMessage());
}

Muli, kapag pinatakbo namin ang aming code, nakukuha namin ang sumusunod na output: Well, iyon lang para sa araw na ito! See you sa susunod na bahagi!