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

Kumusta muli, sa lahat! Patuloy kaming naghahanap ng mga sagot sa mga tanong para sa junior, mid-level at senior na mga developer ng Java. Ang mga tanong ay sobrang kawili-wili. Personal kong gustong suriin ang mga ito, dahil nakakatulong ito sa akin na makahanap ng mga gaps sa aking teoretikal na kaalaman, at sa mga hindi inaasahang lugar kung minsan. 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 nagsasapawan sa seryeng ito ng mga artikulo upang hindi ma-duplicate ang impormasyon nang hindi kinakailangan. Inirerekomenda kong basahin ang mga artikulong ito habang sinasaklaw ng mga ito ang pinakakaraniwang (sikat) na mga tanong sa panayam ng Java Core.
2. Maaari kong ilarawan ang mga sagot nang mas detalyado, ngunit hindi ko gagawin, dahil ang bawat sagot ay maaaring i-drag para sa buong artikulo. At walang magtatanong sa iyo para sa antas ng detalyeng iyon sa anumang pakikipanayam sa trabaho.

Mag-iiwan ako ng mga link para sa mas malalim na pag-aaral kung gusto mo. Lumipad tayo!

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

Ang klase ng Bagay ay may 11 pamamaraan:

1. Class<?> getClass() — kunin ang klase ng kasalukuyang object;

2. int hashCode() — kunin ang hash code ng kasalukuyang object;

3. boolean equals(Object obj) — ihambing ang kasalukuyang bagay sa isa pang bagay;

4. Object clone() — lumikha at magbalik ng kopya ng kasalukuyang bagay;

5. String toString() — makuha ang string na representasyon ng object;

6. void notify() — gisingin ang isang thread na naghihintay sa monitor ng object na ito (ang pagpili ng thread ay random);

7. void notifyAll() — gisingin ang lahat ng mga thread na naghihintay sa monitor ng bagay na ito;

8. void wait() — gawin ang kasalukuyang thread na maghintay sa kasalukuyang monitor (i-freeze ang kasalukuyang thread) hanggang sa isang abiso o abisoLahat ng tawag ay nagising sa thread (gumagana lamang sa isang naka-synchronize na bloke);

9. void wait(long timeout) — gawin ang kasalukuyang thread na maghintay sa kasalukuyang monitor (sa kasalukuyang naka-synchronize na block), ngunit may timeout para sa paglabas sa waiting state (o muli, hanggang sa isang abiso o abisoLahat ng tawag ay magising sa thread);

10. void wait(long timeout, int nanos) — ang pamamaraang ito ay katulad ng naunang pamamaraan, ngunit may mas tumpak na timeout;

11. void finalize() — ang pamamaraang ito ay tinatawag (sa wakas) bago alisin ang bagay ng tagakolekta ng basura. Ginagamit ito upang linisin ang mga nakuhang mapagkukunan.

Upang magamit nang tama ang hashCode , equals , clone , toString , at i-finalize ang mga pamamaraan, dapat na ma-override ang mga ito ayon sa mga detalye ng kasalukuyang gawain.

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

Karaniwan, kapag gumagamit ng try-catch-finally , ang panghuling bloke ay ginagamit upang isara ang mga mapagkukunan. Ipinakilala ng Java 7 ang bagong pahayag ng try-with-resources . Ito ay kahalintulad sa try-catch-finally para sa pagpapalaya ng mga mapagkukunan, ngunit mas compact at nababasa. Alalahanin 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();
}

Ngayon na kahit papaano ay mas simple, sa tingin mo? Bilang karagdagan sa mas simpleng code, mayroong ilang iba pang mga punto na dapat tandaan:

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

   Ang malapit na paraan ay isinasagawa sa isang implicit finally block , kung hindi, paano malalaman ng programa kung paano eksaktong isasara ang mapagkukunan?

   Ngunit malamang na bihira kang magsulat ng iyong sariling mga pagpapatupad ng mga mapagkukunan at ang kanilang paraan ng pagsasara.

2. Ang mga bloke ay isinasagawa sa ganitong pagkakasunud-sunod:

   1. Ang try block.
   2. Ang implicit sa wakas ay hinarangan.
   3. Ang catch block, na nakakakuha ng mga exception na nangyari sa mga nakaraang hakbang.
   4. Ang tahasan sa wakas ay humarang.

   Bilang isang patakaran, ang mga pagbubukod na itinapon sa ibaba sa listahan ay nakakaabala sa mga itinapon sa itaas.

Isipin na gumagamit ka ng try-catch-finally at makakakuha ka ng exception sa try block. Pagkatapos ang tinukoy na catch block ay agad na magsisimulang magsagawa, kung saan nagsulat kami ng isa pang pagbubukod (halimbawa, na may isang mensahe na naglalarawan ng error nang mas detalyado), at gusto mong itapon ng pamamaraan ang pagbubukod na ito pataas. Pagkatapos ay ang pangwakas na bloke ay naisakatuparan, at ang isang pagbubukod ay itinapon din dito. Pero iba na sa pagkakataong ito. Alin sa dalawang pagbubukod na ito ang itatapon sa huli? Ang pagbubukod na itinapon ng panghuling bloke! Ngunit ngayon ay nakarating na tayo sa isa pang punto tungkol sa try-with-resources . Isaalang-alang natin kung paano kumikilos ang mga try-with-resource sa parehong sitwasyon. Nakakakuha kami ng exception sa try block kapag sinusubukang isara ang mga resources sa close() method, ibig sabihin, sa implicit finally block. Alin sa mga pagbubukod na ito ang mahuhuli ng catch block ? Yung ibinato ng try block! Ang pagbubukod mula sa implicit finally block (mula sa lose() method) ay hindi papansinin. Ang pagbabalewala sa mga eksepsiyon ay tinatawag ding exception suppression.

13. Ano ang mga bitwise na operasyon?

Ang mga pagpapatakbo ng bitwise ay mga pagpapatakbo sa mga pagkakasunud-sunod ng mga bit. Kasama sa mga ito ang mga lohikal na operasyon at bitwise shift. Mga lohikal na operator:

• bitwise AND — Naghahambing ng mga bit value. Ang anumang bit na nakatakda sa 0 (false) ay nagtatakda ng katumbas na bit sa resulta sa 0. Ibig sabihin, kung ang isang bit ay 1 (totoo) sa parehong mga pinaghahambing na halaga, kung gayon ang magreresultang bit ay magiging 1 din.

  Tinutukoy bilang AT o &

  Halimbawa: 10111101 at 01100111 = 00100101

• bitwise O — Ang operasyong ito ay kabaligtaran ng nauna. Ang anumang bit na nakatakda sa 1 ay nagtatakda ng katumbas na bit sa resulta sa 1. Alinsunod dito, kung ang bit ay 0 sa parehong pinaghahambing na mga halaga, kung gayon ang magreresultang bit ay magiging 0 din.

  Tinutukoy bilang OR o |

  Halimbawa: 10100101 | 01100011 = 11100111

• bitwise HINDI — Ang operator na ito ay inilapat sa isang halaga. Ito flips (inverts) ang bits. Iyon ay, ang mga bit na 1 ay naging 0; at ang mga naging 0 ay naging 1.

  Tinutukoy bilang HINDI o ~

  Halimbawa: ~10100101 = 01011010

• bitwise exclusive OR — Naghahambing ng mga bit value. Kung ang parehong bit ay 1, kung gayon ang resultang bit ay 0. Kung ang parehong mga bit ay 0, ang resultang bit ay 0. Sa madaling salita, upang ang resultang bit ay maging 1, isa lamang sa mga bit ay dapat na 1, at ang isa pang bit ay dapat na 0.

  Tinutukoy bilang XOR o ^

  Halimbawa: 10100101 ^ 01100011 = 11000110

Ang mga bitwise shift ( >> at << ) ay inilipat ang mga bit ng operand sa tinukoy na direksyon, ayon sa tinukoy na bilang ng mga lugar. Ang mga bakanteng posisyon ay puno ng mga zero. Halimbawa:

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

Ang pagbubukod ay kapag inilipat mo ang isang negatibong numero sa kanan. Tulad ng maaalala mo, ang unang bit ng isang nilagdaang numero ay nagpapahiwatig ng tanda. Kung ang bit na ito ay 1, kung gayon ang numero ay negatibo. Kung ililipat mo ang isang negatibong numero, ang mga nabakanteng posisyon ay hindi napupunan ng mga zero, ngunit sa halip ng mga isa, dahil ang sign bit ay dapat na mapanatili. Halimbawa: 10100010 >> 2 = 11101000 Sabi nga, may karagdagang unsigned right shift operator ang Java (>>>). Ang operator na ito ay kahalintulad sa >>, ngunit kapag inilipat, ang mga bakanteng posisyon ay mapupunan ng 0, hindi alintana kung ang operand ay negatibong numero o positibong numero. Halimbawa: 10100010 >>> 2 = 00101000 Magbasa nang higit pa tungkol sa mga pagpapatakbo ng bitwise dito . Maaari mong kunin ang hash() na pamamaraan sa HashMaps bilang isang halimbawa ng mga bitwise shift sa Java. Ginagamit ang paraang ito upang matukoy ang espesyal na panloob na hashcode ng key: Hinahayaan ka ng paraang ito na pantay-pantay na ipamahagi ang data sa isang HashMap, upang mabawasan ang bilang ng mga banggaan.

14. Anong mga karaniwang bagay na hindi nababago ang mayroon sa Java?

Ang isang bagay ay hindi nababago kung hindi nito pinapayagan ang mga orihinal na halaga nito na magbago. Maaaring mayroon itong mga pamamaraan na nagbabalik ng mga bagong bagay na may parehong uri na may iba't ibang mga halaga. Ang ilang karaniwang hindi nababagong bagay ay kinabibilangan ng:

• walang alinlangan, ang pinakasikat na hindi nababagong uri ng Java ay String;
• mga pagkakataon ng mga klase ng wrapper na bumabalot ng mga karaniwang uri: Boolean, Character, Byte, Short, Integer, Long, Double, Float;
• BigInteger at BigDecimal na mga bagay, na kadalasang ginagamit para lalo na sa MALAKING numero;
• StackTraceElement na mga bagay na bumubuo sa isang stack trace (halimbawa, ang stack trace ng isang exception);
• isang bagay ng klase ng File — maaari nitong baguhin ang mga file, ngunit sa parehong oras ang object mismo ay nananatiling hindi nagbabago;
• Mga UUID, na kadalasang ginagamit para sa natatanging pagtukoy ng mga elemento;
• lahat ng mga bagay ng mga klase sa java.time package;
• Mga lokal na bagay, na ginagamit upang tukuyin ang isang heograpiko, pulitikal, o kultural na rehiyon.

15. Ano ang mga pakinabang ng hindi nababagong bagay kaysa sa mga ordinaryong bagay?

1. Ang mga hindi nababagong bagay ay ligtas na gamitin sa isang multithreaded na kapaligiran . Ginagawa nila ito upang hindi mo kailangang mag-alala tungkol sa pagkawala ng data dahil sa mga kondisyon ng lahi. Iba ito kaysa kapag nagtatrabaho ka sa mga ordinaryong bagay. Sa kasong iyon, kailangan mong mag-isip at makabuo ng magagandang mekanismo kapag ginagamit ang bagay sa isang parallel na kapaligiran.

2. Ang mga hindi nababagong bagay ay mahusay bilang mga susi sa isang mapa. Kung gumagamit ka ng nababagong bagay bilang isang HashMap key at pagkatapos ay nagbabago ang estado ng object, maaaring malito ang istraktura ng data: mananatili pa rin ang object, ngunit kung gagamit ka ng containsKey(), maaaring hindi mo ito mahanap.

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. Ang isa pang bentahe ay pagkabigo atomicity. Kung ang isang hindi nababagong bagay ay naghagis ng eksepsiyon, hindi ito maiiwan sa isang hindi gustong (sirang) estado.

5. Ang mga klase na ito ay madaling subukan.

6. Hindi mo kailangan ng anumang karagdagang mekanismo tulad ng isang copy constructor o pagpapatupad ng object cloning.

Mga tanong tungkol sa OOP

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

Okay, bentahe ng OOP:

1. Ang mga kumplikadong application ay mas madaling magsulat gamit ang OOP 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 nabawasan sa mga relasyon sa pagitan ng mga bagay.

2. Ang mga application na nakasulat gamit ang OOP ay mas madaling baguhin (kapag ang mga prinsipyo ng disenyo ay maayos na sinusunod).

3. Dahil pareho ang data at data operations ay bumubuo ng isang solong entity, hindi sila na-smeared sa buong application (na kadalasang nangyayari sa procedural programming).

4. Pinoprotektahan ng prinsipyo ng encapsulation ang pinaka kritikal na data mula sa user.

5. Ang parehong code ay maaaring magamit muli sa iba't ibang data dahil hinahayaan ka ng mga klase na lumikha ng maraming mga bagay, bawat isa ay may sariling mga halaga.

6. Hinahayaan ka rin ng inheritance at polymorphism na muling gamitin at palawigin ang umiiral na code (sa halip na duplicate ang katulad na functionality).

7. Ang pagpapalawak ng aplikasyon ay mas simple kaysa sa pamamaraang pamamaraan.

8. Ginagawang posible ng diskarte sa OOP na i-abstract ang mga detalye ng pagpapatupad.

17. Sabihin sa amin kung ano ang mga kawalan ng OOP

Sa kasamaang palad, mayroon din sila:

1. Ang OOP ay nangangailangan ng maraming teoretikal na kaalaman na dapat pinagkadalubhasaan bago ka makapagsulat ng anuman.

2. Ang mga ideya sa OOP ay hindi gaanong madaling maunawaan at mailapat sa pagsasanay (kailangan mong maging isang maliit na pilosopo sa puso).

3. Bahagyang binabawasan ng OOP ang pagganap ng isang programa dahil sa tumaas na pagiging kumplikado 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 sa pamamaraang pamamaraan.

18. Ano ang static polymorphism versus dynamic polymorphism?

Binibigyang-daan ng polymorphism ang mga bagay ng parehong klase o interface na kumilos nang iba. Mayroong dalawang uri ng polymorphism, na kilala rin bilang maaga at huli na pagbubuklod. Static polymorphism, o 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 panghuling pamamaraan;
• ang mana ay hindi kasama sa maagang pagbubuklod;
• Ang static na polymorphism ay hindi nagsasangkot ng mga partikular na bagay, ngunit sa halip ay impormasyon tungkol sa uri ng klase na lumilitaw sa kaliwa ng isang variable na pangalan.

Dynamic na polymorphism, o late binding:

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

19. Magbigay ng kahulugan ng prinsipyo ng abstraction sa OOP

Sa OOP, ang abstraction ay isang paraan upang ihiwalay ang isang hanay ng mga makabuluhang katangian ng isang bagay, habang hindi kasama ang mga hindi gaanong mahalagang detalye. Iyon ay, kapag nagdidisenyo ng isang programa na may diskarte sa OOP, tumutuon ka sa mga pangkalahatang modelo, nang hindi napupunta sa mga detalye ng kanilang pagpapatupad. Sa Java, ang abstraction ay naisasakatuparan sa pamamagitan ng mga interface . Halimbawa, mayroon kang kotse at iyon ay magiging isang interface. At ang iba't ibang mga pakikipag-ugnayan dito - halimbawa, pagsisimula ng makina, paglilipat ng mga gears - ay mga function, na ginagamit namin nang hindi nagsusuri sa mga detalye ng pagpapatupad. Sa katunayan, kapag nagmamaneho ka, hindi mo iniisip ang eksaktong paraan kung paano tinutupad ng gearbox ang layunin nito, o kung paano sinisimulan ng susi ang makina, o kung paano eksaktong pinaikot ng manibela ang mga gulong. At kung papalitan mo ang pagpapatupad ng ilang pag-andar (halimbawa, ang makina), maaaring hindi mo ito mapansin. Hindi mahalaga sa iyo: hindi mo malalaman ang mga detalye ng pagpapatupad. Ang mahalaga sa iyo ay natupad ang aksyon. Sa esensya, inalis nito ang mga detalye ng pagpapatupad. Sa puntong ito, titigil tayo ngayon: itutuloy!