Pagsusuri ng mga tanong at sagot mula sa mga panayam para sa developer ng Java. Bahagi 2

Hello ulit sa lahat! Patuloy kaming naghahanap ng mga sagot sa 250+ na tanong para sa mga developer ng Junior, Middle at Senior. Ang mga tanong ay medyo kawili-wili, at gusto ko mismo na pag-aralan ang mga ito: sa gayong mga sandali maaari mong matuklasan ang mga puwang sa teoretikal na kaalaman, at sa mga hindi inaasahang lugar. Ang nakaraang bahagi ay matatagpuan sa artikulong ito . Ngunit bago tayo magsimula, nais kong ipaalala sa iyo na:

1. Laktawan ko ang mga tanong na bumabagtas sa seryeng ito ng mga artikulo upang hindi na muling madoble ang impormasyon. Inirerekomenda kong basahin ang mga materyal na ito, dahil naglalaman ang mga ito ng pinakakaraniwang (sikat) na mga tanong sa panayam ng Java Core.
2. Ang mga tanong sa DOU ay iniharap sa Ukrainian, ngunit makukuha ko ang lahat dito sa Russian.
3. Ang mga sagot ay maaaring ilarawan nang mas detalyado, ngunit hindi ko gagawin, mula noon ang sagot sa bawat tanong ay maaaring tumagal ng isang buong artikulo. At hindi ka nila tatanungin nang detalyado sa anumang panayam.

Kung kinakailangan, mag-iiwan ako ng mga link para sa mas malalim na pag-aaral. Lumipad tayo!

11. Pangalanan ang lahat ng mga pamamaraan ng klase ng Bagay

Ang klase ng Bagay ay may 11 pamamaraan:

• Class<?> getClass() — pagkuha ng klase ng kasalukuyang object;
• int hashCode() — pagkuha ng hash code ng kasalukuyang object;
• boolean equals​(Object obj) - paghahambing ng kasalukuyang bagay sa isa pa;
• Object clone() - paglikha at pagbabalik ng kopya ng kasalukuyang bagay;
• String toString() — pagkuha ng string na representasyon ng isang bagay;
• void notify() - paggising ng isang thread na naghihintay sa monitor ng bagay na ito (ang pagpili ng thread ay random);
• void notifyAll() - ginigising ang lahat ng mga thread na naghihintay sa monitor ng bagay na ito;
• void wait() - inililipat ang kasalukuyang thread sa standby mode (nai-freeze ito) sa kasalukuyang monitor, gumagana lamang sa isang naka-synchronize na bloke hanggang sa abisuhan o ipaalam ng ilan ang lahat ng thread;
• void wait(long timeout) - nag-freeze din sa kasalukuyang thread sa kasalukuyang monitor (sa kasalukuyang naka-synchronize), ngunit may timer para lumabas sa estadong ito (o muli: hanggang sa ma-notify o ma-notifyAll wakes up);
• void wait(mahabang timeout, int nanos) - isang paraan na katulad ng inilarawan sa itaas, ngunit may mas tumpak na mga timer para sa pag-alis sa pagyeyelo;
• void finalize() - bago tanggalin ang bagay na ito, tinawag ng tagakolekta ng basura ang pamamaraang ito (sa wakas). Ito ay ginagamit upang linisin ang mga pinagkukunang yaman.

Upang magamit nang tama ang hashCode , equals​ , clone , toString , at i-finalize ang mga pamamaraan, dapat na muling tukuyin ang mga ito, na isinasaalang-alang ang kasalukuyang gawain at mga pangyayari.

12. Ano ang pagkakaiba ng try-with-resources at try-catch-finally kapag nakikitungo sa resources?

Karaniwan, kapag gumagamit ng try-catch-finally, ginamit ang panghuling bloke upang isara ang mga mapagkukunan. Ipinakilala ng Java 7 ang isang bagong uri ng operator try-with-resources , isang analogue ng try-catch-finally para sa pagpapalaya ng mga mapagkukunan, ngunit mas compact at nababasa. Tandaan natin kung ano ang hitsura ng try-catch-finally :

String text = "some text......";
BufferedWriter bufferedWriter = null;
try {
   bufferedWriter = new BufferedWriter(new FileWriter("someFileName"));
   bufferedWriter.write(text);
} catch (IOException e) {
   e.printStackTrace();
} finally {
   try {
       bufferedWriter.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
}

Ngayon ay muling isulat natin ang code na ito, ngunit gamit ang try-with-resources :

String text = "some text......";
try(BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("someFileName"))) {
   bufferedWriter.write(text);
} catch (IOException e) {
   e.printStackTrace();
}

Ito ay kahit papaano ay naging mas madali, hindi ba? Bilang karagdagan sa pagpapasimple, mayroong ilang mga puntos:

1. Sa try-with-resources , ang mga mapagkukunang ipinahayag sa mga panaklong (na isasara) ay dapat ipatupad ang AutoCloseable na interface at ang tanging paraan nito, close() .

   Ang malapit na pamamaraan ay isinasagawa sa isang implicit finally block , kung hindi, paano maiintindihan ng program ang eksaktong paraan kung paano isara ang isang ibinigay na mapagkukunan?

   Ngunit, malamang, bihira mong isulat ang iyong sariling mga pagpapatupad ng mga mapagkukunan at ang kanilang paraan ng pagsasara.

2. Sequence ng block execution:

   1. subukan mong i-block .
   2. Implicit sa wakas .
   3. Isang catch block na nakakakuha ng mga exception sa mga nakaraang hakbang.
   4. Tahasang sa wakas .

   Bilang isang panuntunan, ang mga pagbubukod na lumalabas na mas mababa sa listahan ay nakakaabala sa mga lumalabas na mas mataas.

Isipin ang isang sitwasyon kung saan kapag gumagamit ng try-catch-finally isang exception ang nangyayari sa iyong try . Alinsunod dito, ang isang partikular na catch block ay agad na magsisimulang magsagawa , kung saan sumulat ka ng isa pang pagbubukod (halimbawa, na may isang mensahe na naglalarawan ng error nang mas detalyado), at gusto mong itapon pa ng paraan ang pagbubukod na ito. Susunod ay ang pagpapatupad ng pangwakas na block , at isang pagbubukod ay itinapon din dito. Ngunit ito ay naiiba. Alin sa dalawang pagbubukod na ito ang itatapon sa huli? Exception na itinapon ng finally block ! Ngunit mayroon ding isang punto sa try-with-resources . Ngayon tingnan natin ang pag-uugali ng try-with-resources sa parehong sitwasyon. Nakakakuha kami ng exception sa try block kapag sinubukan naming isara ang mga resources sa close() method , iyon ay, sa implicit finally . Alin sa mga pagbubukod na ito ang mahuhuli ? Yung hinagis ng try block ! Ang isang exception mula sa isang implicit finally (mula sa close() method ) ay hindi papansinin. Ang pagbabalewala na ito ay tinatawag ding exception suppression.

13. Ano ang mga bitwise na operasyon?

Ang mga pagpapatakbo ng bitwise ay mga pagpapatakbo sa mga bit string na kinabibilangan ng mga lohikal na operasyon at mga pagbabago sa bitwise. Mga lohikal na operasyon:

• bitwise AND - inihahambing ang mga bit value, at sa proseso, ang anumang bit na nakatakda sa 0 (false) ay nagtatakda ng katumbas na bit sa resulta bilang 0. Iyon ay, kung sa parehong mga halaga ay inihambing ang bit ay 1 (true), ang magiging 1 din ang resulta.

  Tinutukoy bilang - AT , &

  Halimbawa: 10111101 at 01100111 = 00100101

• bitwise OR ay ang kabaligtaran na operasyon ng nauna. Ang anumang bit na nakatakda sa 1 ay nagtatakda ng kaparehong bit sa resulta bilang 1. At ayon dito, kung ang bit ay 0 sa parehong pinaghahambing na mga halaga, ang resultang bit ay magiging 0 din.

  Tinutukoy bilang - O , |

  Halimbawa: 10100101 | 01100011 = 11100111

• bitwise NOT - inilapat sa isang halaga, flips (inverts) ang bits. Iyon ay, ang mga bit na 1 ay magiging 0; at ang mga naging 0 ay magiging 1.

  Tinutukoy bilang - HINDI , ~

  Halimbawa: ~10100101 = 01011010

• bitwise exclusive OR - naghahambing ng mga bit na halaga, at kung sa parehong mga halaga ang bit ay katumbas ng 1, kung gayon ang resulta ay magiging 0, at kung sa parehong mga halaga ang bit ay 0, ang resulta ay magiging 0. Iyon ay, para ang resulta ay katumbas ng 1, isa lamang sa mga bit ay dapat na katumbas ng 1, at ang pangalawa ay katumbas ng 0.

  Tinutukoy bilang - XOR , ^

  Halimbawa: 10100101 ^ 01100011 = 11000110

Bitwise shifts - >> o << shift ang mga bit ng isang value sa tinukoy na direksyon, ayon sa tinukoy na numero. Ang mga nabakanteng posisyon ay puno ng mga zero. Halimbawa:

1. 01100011 >> 4 = 00000110
2. 01100011 << 3 = 00011000

Mayroon ding exception kapag right shifting ng negative number. Tulad ng naaalala mo, ang unang bit ay responsable para sa pag-sign, at kung ang bit na ito ay katumbas ng 1, kung gayon ang numero ay negatibo. Kung ililipat mo ang isang negatibong numero, ang mga nabakanteng posisyon ay hindi na mapupuno ng mga zero, ngunit may mga isa, dahil ito ay kinakailangan upang mapanatili ang sign bit. Halimbawa: 10100010 >> 2 = 11101000 Kasabay nito, sa Java mayroong isang karagdagang unsigned right shift operator >>> Ang operator na ito ay isang analogue ng >>, kapag lumilipat, ang mga nabakanteng posisyon ay puno ng 0, hindi alintana kung ang bilang ay negatibo o positibo. Halimbawa: 10100010 >>> 2 = 00101000 Magbasa nang higit pa tungkol sa mga pagpapatakbo ng bitwise dito . Bilang mga halimbawa ng paggamit ng mga bitwise shift sa Java, maaari mong banggitin ang hash() na paraan ng isang HashMap, na ginagamit upang matukoy ang isang espesyal na internal na hash code para sa isang susi: Ang paraang ito ay nagbibigay-daan sa iyong pantay na mamahagi ng data sa isang HashMap upang mabawasan ang daming banggaan.

14. Anong mga karaniwang hindi nababagong klase ang mga bagay sa Java?

Ang hindi nababago ay isang bagay na hindi pinapayagan ang mga orihinal na parameter nito na mabago. Maaaring mayroon itong mga pamamaraan na nagbabalik ng mga bagong bagay ng isang partikular na uri, na may mga parameter na gusto mong baguhin. Ilang karaniwang hindi nababagong bagay:

• Sa ngayon, ang pinakatanyag na hindi nababagong bagay sa Java ay String;
• mga pagkakataon ng mga klase ng wrapper na bumabalot ng mga karaniwang uri: Boolean, Character, Byte, Short, Integer, Long, Double, Float;
• mga bagay na karaniwang ginagamit para lalo na sa MALAKING numero - BigInteger at BigDecimal;
• isang bagay na isang yunit sa stacktraces (halimbawa, sa isang exception stacktrace) StackTraceElement;
• isang bagay ng klase ng File - maaaring magbago ng mga file, ngunit sa parehong oras ito mismo ay hindi nababago;
• UUID - na kadalasang ginagamit bilang isang natatanging id para sa mga elemento;
• lahat ng class object ng java.time package;
• Lokal - ginagamit upang tukuyin ang isang heograpiko, pulitikal, o kultural na rehiyon.

15. Ano ang mga pakinabang ng isang hindi nababagong bagay kaysa sa mga regular na bagay?

1. Ang mga naturang bagay ay ligtas kapag ginamit sa isang multi-threaded na kapaligiran . Sa paggamit ng mga ito, hindi mo kailangang mag-alala tungkol sa pagkawala ng data dahil sa mga kundisyon ng thread race. Hindi tulad ng pagtatrabaho sa mga ordinaryong bagay: sa kasong ito, kailangan mong mag-isip nang mabuti at magsagawa ng mga mekanismo para sa paggamit ng bagay sa isang parallel na kapaligiran.
2. Ang mga hindi nababagong bagay ay mahusay na mga susi sa isang mapa, dahil kung gumamit ka ng nababagong bagay at pagkatapos ay binago ng object ang estado nito, maaari itong maging nakalilito kapag gumagamit ng HashMap: ang bagay ay naroroon pa rin, at kung gagamit ka ng containsKey() maaaring hindi ito matagpuan.
3. Ang mga hindi nababagong bagay ay mahusay para sa pag-iimbak ng hindi nababago (pare-pareho) na data na hindi dapat baguhin habang tumatakbo ang programa.
4. "Atomicity to failure" - kung ang isang hindi nababagong bagay ay naghagis ng eksepsiyon, hindi pa rin ito mananatili sa isang hindi ginustong (sirang) estado.
5. Ang mga klase na ito ay madaling subukan.
6. Ang mga karagdagang mekanismo tulad ng isang copy constructor at clone na pagpapatupad ay hindi kailangan.

Mga tanong tungkol sa OOP

16. Ano ang mga pakinabang ng OOP sa pangkalahatan at kumpara sa procedural programming?

Kaya, ang mga pakinabang ng OOP:

1. Ang mga kumplikadong application ay mas madaling magsulat kaysa sa procedural programming, dahil ang lahat ay nahahati sa maliliit na module - mga bagay na nakikipag-ugnayan sa isa't isa - at bilang isang resulta, ang programming ay bumaba sa mga relasyon sa pagitan ng mga bagay.
2. Ang mga application na nakasulat gamit ang OOP ay mas madaling baguhin (hangga't ang mga konsepto ng disenyo ay sinusunod).
3. Dahil ang data at mga operasyon dito ay bumubuo ng isang solong entity, ang mga ito ay hindi smeared sa buong application (na kadalasang nangyayari sa procedural programming).
4. Pinoprotektahan ng encapsulation ng impormasyon ang pinakamahalagang data mula sa user.
5. Posibleng muling gamitin ang parehong code na may iba't ibang data, dahil pinapayagan ka ng mga klase na lumikha ng maraming mga bagay, na ang bawat isa ay may sariling mga halaga ng katangian.
6. Binibigyang-daan ka rin ng inheritance at polymorphism na muling gamitin at palawigin ang umiiral na code (sa halip na duplicate ang katulad na functionality).
7. Mas madaling pagpapalawak ng aplikasyon kaysa sa pamamaraang pamamaraan.
8. Ginagawang posible ng diskarte sa OOP na mag-abstract mula sa mga detalye ng pagpapatupad.

17. Sabihin sa amin kung anong mga pagkukulang ang mayroon sa OOP

Sa kasamaang palad, naroroon din sila:

1. Ang OOP ay nangangailangan ng maraming teoretikal na kaalaman na kailangang ma-master bago ka makapagsulat ng anuman.
2. Ang mga ideya ng OOP ay hindi napakadaling maunawaan at mailapat sa pagsasanay (kailangan mong maging isang pilosopo sa puso).
3. Kapag gumagamit ng OOP, bahagyang nababawasan ang pagganap ng software dahil sa mas kumplikadong organisasyon ng system.
4. Ang diskarte sa OOP ay nangangailangan ng higit na memorya, dahil ang lahat ay binubuo ng mga klase, interface, pamamaraan, na kumukuha ng mas maraming memorya kaysa sa mga ordinaryong variable.
5. Ang oras na kinakailangan para sa paunang pagsusuri ay mas malaki kaysa para sa pamamaraan.

18. Ano ang static at dynamic polymorphism

Ang polymorphism ay nagpapahintulot sa mga bagay na kumilos nang naiiba para sa parehong klase o interface. Mayroong dalawang uri ng polymorphism, na kilala rin bilang early- at late-binding . Static polymorphism, o mas maagang pagbubuklod:

• nangyayari sa oras ng pag-compile (maaga sa ikot ng buhay ng programa);
• nagpapasya kung aling paraan ang isasagawa sa oras ng pag-compile;
• Ang paraan ng overloading ay isang halimbawa ng static polymorphism;
• Ang maagang pagbubuklod ay kinabibilangan ng pribado, static, at mga pamamaraan ng terminal;
• ang mana ay hindi kasama sa maagang pagbubuklod;
• Ang static na polymorphism ay hindi nagsasangkot ng mga partikular na bagay, ngunit ang impormasyon tungkol sa klase, ang uri nito ay kinakatawan sa kaliwa ng variable na pangalan.

Dynamic na polymorphism, o late binding:

• nangyayari sa runtime (habang tumatakbo ang programa);
• ang dynamic na polymorphism ay nagpapasya kung anong partikular na pagpapatupad ang magkakaroon ng paraan sa runtime;
• paraan overriding ay isang halimbawa ng dynamic polymorphism;
• ang late binding ay ang pagtatalaga ng isang partikular na bagay, isang sanggunian ng uri nito, o superclass nito;
• Ang pamana ay nauugnay sa dynamic na polymorphism.

Maaari kang magbasa nang higit pa tungkol sa mga pagkakaiba sa pagitan ng maaga at huli na pagbubuklod sa artikulong ito .

19. Tukuyin ang prinsipyo ng abstraction sa OOP

Ang abstraction sa OOP ay isang paraan upang i-highlight ang isang hanay ng mga makabuluhang katangian ng isang bagay, hindi kasama ang mga hindi mahalagang detalye. Iyon ay, kapag nagdidisenyo ng isang programa na may diskarte sa OOP, tumutuon ka sa mga modelo sa pangkalahatan, nang hindi nagsusuri sa mga detalye ng kanilang pagpapatupad. Sa Java, ang mga interface ay responsable para sa abstraction . Halimbawa, mayroon kang makina, at ito ang magiging interface. At iba't ibang mga pakikipag-ugnayan dito - halimbawa, pagsisimula ng makina, gamit ang gearbox - ito ang mga pag-andar na ginagamit namin nang hindi pumapasok sa mga detalye ng pagpapatupad. Pagkatapos ng lahat, sa sandaling nagmamaneho ka ng kotse, hindi mo iniisip kung paano eksaktong tinutupad ng gearbox ang layunin nito, o kung paano sinisimulan ng susi ang makina, o eksakto kung paano pinaikot ng manibela ang mga gulong. At kahit na ang pagpapatupad ng isa sa mga pag-andar na ito ay pinalitan (halimbawa, ang makina), maaaring hindi mo ito mapansin. Hindi ito mahalaga sa iyo: hindi ka pumunta sa mga detalye ng pagpapatupad. Mahalaga para sa iyo na ang aksyon ay natupad. Sa totoo lang, ito ay abstraction mula sa mga detalye ng pagpapatupad. Dito tayo titigil ngayon: itutuloy!