Java Core. Mga tanong para sa isang panayam, bahagi 3

Sa nakaraang dalawang artikulo, tinalakay namin ang ilang mahahalagang tanong na madalas itanong sa iyo sa mga panayam. Oras na para magpatuloy at tingnan ang iba pang mga tanong.

Malalim na pagkopya at mababaw na pagkopya

Ang eksaktong kopya ng orihinal ay ang clone nito. Sa Java, nangangahulugan ito ng kakayahang lumikha ng isang bagay na may katulad na istraktura sa orihinal na bagay. Ang pamamaraan clone()ay nagbibigay ng pag-andar na ito. Ang mababaw na pagkopya ng mga kopya ng kaunting impormasyon hangga't maaari. Bilang default, ang pag-clone sa Java ay mababaw, i.e. Object classhindi alam ang tungkol sa istruktura ng klase na kinokopya nito. Kapag nag-clone, ginagawa ng JVM ang sumusunod:

1. Kung ang isang klase ay mayroon lamang mga miyembro ng primitive na uri, pagkatapos ay isang ganap na bagong kopya ng object ay gagawin at isang reference sa object na iyon ay ibabalik.
2. Kung ang isang klase ay naglalaman ng hindi lamang mga miyembro ng primitive na uri, kundi pati na rin ang anumang iba pang uri ng klase, kung gayon ang mga sanggunian sa mga bagay ng mga klase na ito ay kinokopya. Samakatuwid, ang parehong mga bagay ay magkakaroon ng parehong mga sanggunian.

Ang malalim na pagkopya ay nadoble ang lahat. Ang malalim na pagkopya ay dalawang koleksyon, ang isa ay duplicate ang lahat ng elemento ng orihinal na koleksyon. Gusto naming gumawa ng kopya na ang paggawa ng mga pagbabago sa anumang elemento ng kopya ay hindi makakaapekto sa orihinal na koleksyon. Ang malalim na pag-clone ay nangangailangan ng mga sumusunod na patakaran:

1. Hindi na kailangang kopyahin nang hiwalay ang primitive na data;
2. Dapat suportahan ng lahat ng klase ng miyembro sa orihinal na klase ang pag-clone. Para sa bawat miyembro ng klase, dapat tawagan super.clone()kapag na-override ang pamamaraan clone();
3. Kung ang sinumang miyembro ng isang klase ay hindi sumusuporta sa pag-clone, pagkatapos ay sa clone na paraan, kailangan mong lumikha ng isang bagong instance ng klase na iyon at kopyahin ang bawat miyembro nito na may lahat ng mga katangian sa isang bagong object ng klase, nang paisa-isa.

Alamin ang higit pa tungkol sa pag-clone dito

Ano ang synchronization? Pag-lock sa antas ng bagay at pag-lock sa antas ng klase?

Ang pag-synchronize ay tumutukoy sa multithreading. Ang isang naka-synchronize na bloke ng code ay maaari lamang isagawa ng isang thread sa isang pagkakataon. Binibigyang-daan ka ng Java na magproseso ng maramihang mga thread nang sabay-sabay. Ito ay maaaring magresulta sa dalawa o higit pang mga thread na gustong ma-access ang parehong field. Nakakatulong ang pag-synchronize na maiwasan ang mga error sa memorya na nangyayari kapag ginamit nang hindi tama ang mga mapagkukunan ng memorya. Kapag ang isang paraan ay idineklara bilang naka-synchronize, hawak ng thread ang monitor nito. Kung ang isa pang thread ay sumusubok na mag-access ng isang naka-synchronize na paraan sa oras na ito, ang thread ay naharang at naghihintay para sa monitor na maging libre. Ang synchronization sa Java ay nagagawa gamit ang espesyal na naka-synchronize na keyword . Maaari mong markahan ang mga indibidwal na bloke o pamamaraan sa iyong klase sa ganitong paraan. Ang naka-synchronize na keyword ay hindi maaaring gamitin kasabay ng mga variable o attribute ng klase. Ang Object-level na locking ay isang mekanismo kapag gusto mong i-synchronize ang isang non-static na paraan o non-static na block ng code para isang thread lang ang makakapag-execute ng block ng code sa isang partikular na instance ng klase. Dapat itong palaging gawin upang gawing ligtas ang thread ng halimbawa ng klase. Pinipigilan ng pag-lock ng antas ng klase ang maraming thread na pumasok sa isang naka-synchronize na bloke para sa lahat ng available na pagkakataon ng klase. Halimbawa, kung mayroong 100 instance ng DemoClass class, 1 thread lang ang makakapag-execute ng demoMethod() gamit ang isa sa mga variable sa isang partikular na oras. Dapat itong palaging gawin upang matiyak ang kaligtasan ng static na thread. Matuto nang higit pa tungkol sa pag-synchronize dito.

Ano ang pagkakaiba ng sleep() at wait()?

Sleep()ay isang paraan na ginagamit upang maantala ang proseso ng ilang segundo. Sa kaso ng wait(), ang thread ay nasa isang naghihintay na estado hanggang sa tawagin natin ang notify()or method notifyAll(). Ang pangunahing pagkakaiba ay ang wait()paglabas nito ng lock ng monitor habang sleep()hindi nito nilalabas ang lock. Wait()ginagamit para sa mga multi-threaded na application, sleep()ginagamit lang para i-pause ang thread execution. Thread.sleep()inilalagay ang kasalukuyang thread sa "Not Runnable" na estado para sa isang tiyak na tagal ng panahon. Ang thread ay nagse-save ng estado ng monitor na bago tinawag ang pamamaraang ito. Kung ang isa pang thread ay tumawag t.interrupt(), ang thread na "nakatulog" ay magigising. Tandaan na ito sleep()ay isang static na pamamaraan, ibig sabihin ay palaging nakakaapekto ito sa kasalukuyang thread (ang nagpapatupad ng pamamaraan sleep()). Ang isang karaniwang pagkakamali ay ang tumawag t.sleep()kung saan tang isa pang thread; kahit na ang kasalukuyang thread na tumawag sa pamamaraan sleep()ay hindi tisang thread. Object.wait()ipinapadala ang kasalukuyang thread sa "Not Runnable" na estado nang ilang sandali, tulad ng sleep(), ngunit may kaunting nuance. Wait()tinatawag sa isang bagay, hindi isang thread; tinatawag namin itong object na "lock object". Bago tumawag lock.wait(), ang kasalukuyang thread ay dapat na naka-synchronize sa "lock object"; wait()pagkatapos nito, inilalabas nito ang lock na ito, at idinaragdag ang thread sa "listahan ng paghihintay" na nauugnay sa lock na ito. Sa ibang pagkakataon, ang isa pang thread ay maaaring mag-synchronize sa parehong lock object at tumawag sa lock.notify(). Ang pamamaraang ito ay "gigisingin" ang orihinal na thread, na naghihintay pa rin. Sa prinsipyo, wait()/ notify()ay maihahambing sa sleep()/ interrupt(), tanging ang aktibong thread ay hindi nangangailangan ng direktang pointer sa natutulog na thread, kailangan lamang nitong malaman ang shared lock object. Basahin ang detalyadong pagkakaiba dito.

Posible bang magtalaga ng null dito sa isang reference variable?

Hindi hindi mo kaya. Sa Java, ang kaliwang bahagi ng operator ng pagtatalaga ay dapat na isang variable. Ang "Ito" ay isang espesyal na keyword na palaging nagbibigay ng kasalukuyang instance ng klase. Ito ay hindi lamang anumang variable. Gayundin, ang null ay hindi maaaring italaga sa isang variable gamit ang "super" na keyword o anumang iba pang katulad na keyword.

Ano ang pagkakaiba ng && at &?

&- bitwise at &&- lohikal.

1. &sinusuri ang magkabilang panig ng operasyon;
2. &&sinusuri ang kaliwang bahagi ng operasyon. Kung totoo, patuloy itong sinusuri ang kanang bahagi.

Hanapin dito para sa mas malalim na pang-unawa.

Paano i-override ang equals() at hachCode() na mga pamamaraan?

hashCode()at equals()ang mga pamamaraan ay tinukoy sa class Object, na siyang parent class para sa Java objects. Para sa kadahilanang ito, ang lahat ng Java object ay nagmamana ng default na pagpapatupad para sa mga pamamaraan. Ang pamamaraan hashCode()ay ginagamit upang makakuha ng isang natatanging integer para sa isang naibigay na bagay. Ang integer na ito ay ginagamit upang matukoy ang lokasyon ng isang bagay kapag ang bagay na iyon ay kailangang maimbak, halimbawa sa HashTable. Bilang default, hashCode()nagbabalik integerng representasyon ng address ng lokasyon ng memorya kung saan nakaimbak ang bagay. Ang pamamaraan equls(), gaya ng ipinahihiwatig ng pangalan nito, ay ginagamit upang subukan lamang kung magkapantay ang dalawang bagay. Sinusuri ng default na pagpapatupad ang mga object reference upang makita kung pantay ang mga ito. Nasa ibaba ang mahahalagang alituntunin para sa muling pagkarga ng mga pamamaraang ito:

1. Palaging gamitin ang parehong mga katangian ng bagay kapag bumubuo hashCode()at equals();
2. Simetrya. Yung. xkung nagbabalik ito ng true para sa ilang objects y x.equals(y), dapat itong y.equals(x)bumalik ng true;
3. Reflexivity. Para sa anumang bagay x x.equals(x)ay dapat bumalik totoo;
4. Hindi pagbabago. Para sa anumang bagay xat y x.equals(y)ibinabalik ang parehong bagay kung ang impormasyong ginamit sa paghahambing ay hindi nagbabago;
5. Transitivity. Para sa anumang mga bagay x, yat z, kung x.equals(y)ito ay nagbabalik ng true at y.equals(z)nagbabalik ng totoo, dapat itong x.equals(z)bumalik ng totoo;
6. Sa tuwing ang isang pamamaraan ay tinatawag sa parehong bagay sa panahon ng pagpapatupad ng aplikasyon, dapat itong ibalik ang parehong numero maliban kung ang impormasyong ginamit ay nagbabago. hashCodemaaaring magbalik ng iba't ibang mga halaga para sa magkatulad na mga bagay sa iba't ibang mga pagkakataon ng aplikasyon;
7. Kung ang dalawang bagay ay pantay, ayon sa equals, dapat nilang hashCodeibalik ang parehong mga halaga;
8. Ang kabaligtaran na kinakailangan ay opsyonal. Maaaring ibalik ng dalawang hindi pantay na bagay ang parehong hashCode. Gayunpaman, upang mapabuti ang pagganap, mas mahusay na magkaroon ng iba't ibang mga bagay na nagbabalik ng iba't ibang mga code.

Basahin ang mga kagiliw-giliw na katotohanan tungkol sa mga pamamaraang ito dito.

Sabihin sa amin ang tungkol sa mga modifier ng access

Ang mga class, field, constructor, at method ng Java ay maaaring magkaroon ng isa sa apat na magkakaibang access modifier: pribado Kung ang isang paraan o variable ay minarkahan ng private , kung gayon ang code lamang sa loob ng parehong klase ang makaka-access sa variable, o tumawag sa pamamaraan. Hindi ma-access ng code sa loob ng mga subclass ang isang variable o pamamaraan, at hindi rin ito ma-access mula sa anumang ibang klase. Ang modifier ng pribadong access ay kadalasang ginagamit para sa mga constructor, pamamaraan, at variable. default Ang default na access modifier ay idineklara kung ang modifier ay hindi tinukoy sa lahat. Ang modifier na ito ay nangangahulugan na ang pag-access sa mga field, constructor at pamamaraan ng isang partikular na klase ay maaaring makuha sa pamamagitan ng code sa loob ng klase mismo, code sa loob ng mga klase sa parehong pakete. Hindi maa-access ng mga subclass ang mga pamamaraan at mga variable ng miyembro ng isang superclass kung idineklara ang mga ito bilang default , maliban kung ang subclass ay nasa parehong pakete ng superclass. protected Ang protektadong modifier ay gumagana katulad ng default , maliban na ang mga subclass ay maaari ding ma-access ang mga protektadong pamamaraan at variable ng superclass. Ang pahayag na ito ay totoo kahit na ang subclass ay wala sa parehong pakete ng superclass. public Ang modifier ng pampublikong access ay nangangahulugan na ang lahat ng code ay maaaring ma-access ang klase, ang mga variable, constructor, o pamamaraan nito, saanman matatagpuan ang code na iyon.

Ano ang isang basurero? Tawagan natin siya?

Ang koleksyon ng basura ay isang tampok ng awtomatikong pamamahala ng memorya sa maraming modernong programming language, tulad ng Java at mga wika sa NET.Framework. Ang mga wikang gumagamit ng pangongolekta ng basura ay kadalasang binibigyang kahulugan ang pangongolekta ng basura sa isang virtual machine gaya ng JVM. Ang pangongolekta ng basura ay may dalawang layunin: ang anumang hindi nagamit na memorya ay dapat palayain, at ang memorya ay hindi dapat palayain kung ginagamit pa rin ito ng programa. Maaari mo bang manual na patakbuhin ang pangongolekta ng basura? Hindi, System.gc()binibigyan ka nito ng mas maraming access hangga't maaari. Ang pinakamagandang opsyon ay tawagan ang paraan System.gc(), na magpahiwatig sa kolektor ng basura na kailangan nitong tumakbo. Walang paraan upang patakbuhin ito kaagad dahil ang tagakolekta ng basura ay hindi deterministiko. Bilang karagdagan, ayon sa dokumentasyon, OutOfMemoryErrorhindi ito maipapasa kung nabigo ang virtual machine na magbakante ng memorya pagkatapos ng buong koleksyon ng basura. Matuto pa tungkol sa basurero dito.

Ano ang ibig sabihin ng katutubong keyword? Ipaliwanag nang detalyado

Ang katutubong keyword ay ginagamit upang ipahiwatig na ang pamamaraan ay ipinatupad sa isang programming language maliban sa isang Java file. Ang mga katutubong pamamaraan ay ginamit sa nakaraan. Sa kasalukuyang mga bersyon ng Java ito ay kinakailangan nang mas madalas. Sa kasalukuyan, kailangan ang mga katutubong pamamaraan kapag:

1. Dapat kang tumawag sa isang library mula sa Java na nakasulat sa ibang wika.
2. Kailangan mo ng access sa mga mapagkukunan ng system o hardware na maaari lamang ma-access gamit ang ibang wika (karaniwan ay C). Sa katunayan, maraming mga function ng system na nakikipag-ugnayan sa totoong computer (tulad ng mga disk o data ng network) ay matatawag lamang sa pamamagitan ng katutubong pamamaraan.

Ang mga kawalan ng paggamit ng mga library ng katutubong pamamaraan ay makabuluhan din:

1. Maaaring ma-destabilize ng JNI/JNA ang JVM, lalo na kung susubukan mong gumawa ng isang bagay na kumplikado. Kung may mali sa iyong katutubong pamamaraan, may posibilidad na mag-crash ang JVM. Gayundin, maaaring mangyari ang masasamang bagay kung ang iyong katutubong pamamaraan ay tinawag mula sa maraming mga thread. At iba pa.
2. Mas mahirap i-debug ang isang program na may native code.
3. Ang native code ay nangangailangan ng hiwalay na pagbuo ng mga frameworks, na maaaring lumikha ng mga problema sa pag-port sa ibang mga platform.

Ano ang serialization?

Sa computer science, sa konteksto ng pag-iimbak at paghahatid ng data, ang serialization ay ang proseso ng pagsasalin ng istruktura ng data o ang estado ng isang bagay sa isang format na maaaring iimbak at makuha sa ibang pagkakataon sa ibang computing environment. Pagkatapos makatanggap ng isang serye ng mga bit, sila ay muling kinakalkula ayon sa serialization format, at maaaring magamit upang lumikha ng isang semantically identical clone ng orihinal na bagay. Nagbibigay ang Java ng awtomatikong serialization, na nangangailangan ng object na ipatupad ang interface java.io.Serializable. Ang pagpapatupad ng interface ay minarkahan ang klase bilang "maseries". Ang java.io.Serializable na interface ay walang mga pamamaraan ng serialization, ngunit ang serializable na klase ay maaaring opsyonal na tukuyin ang mga pamamaraan na tatawagin bilang bahagi ng proseso ng serialization/diserialization. Kapag gumagawa ng mga pagbabago sa mga klase, kailangan mong isaalang-alang kung alin ang magiging at hindi tugma sa serialization. Maaari mong basahin ang buong tagubilin dito. Ibibigay ko ang pinakamahalagang punto: Mga hindi tugmang pagbabago:

1. Magtanggal ng field;
2. Ilipat ang isang klase pataas o pababa sa hierarchy;
3. Pagbabago ng non-static na field sa static o non-transient sa transient;
4. Pagbabago ng ipinahayag na primitive na uri ng data;
5. Pagbabago ng paraan WriteObjectupang ReadObjecthindi na sila magsulat o magbasa ng mga field bilang default;
6. Pagpapalit ng klase Serializablesa Externalizableo vice versa;
7. Pagbabago ng isang enum class sa isang non-enum o vice versa;
8. Tinatanggal Serializableo Externalizable;
9. Pagdaragdag writeReplaceng isang readResolveparaan sa isang klase.

Mga katugmang pagbabago:

1. Pagdaragdag ng mga patlang;
2. Pagdaragdag/pag-alis ng mga klase;
3. Pagdaragdag ng mga pamamaraan WriteObject/ReadObject[mga pamamaraan defaultReadObjecto defaultWriteObjectdapat tawagan sa simula];
4. Pag-alis ng mga pamamaraan WriteObject/ReadObject;
5. Dagdag java.io.Serializable;
6. Pagbabago ng access sa field;
7. Pagbabago ng static na field sa non-static o transient sa non-transient .

Mga link sa mga nakaraang bahagi: Java Core. Mga tanong sa panayam, bahagi 1 Java Core. Mga tanong sa panayam, bahagi 2 Orihinal na artikulo Maligayang pag-aaral!