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

Hi! Pinagsama-sama ng CodeGym ang magkakaibang grupo ng mga tao. Ang ilan sa amin ay walang iba kundi ang maging mga developer ng Java, at naglalaan kami ng maraming oras at pagsisikap sa pag-unlad. Ang iba ay mga developer na ng Java. Sa alinmang kaso, kailangan mong maging handa na masuri sa mga teknikal na panayam. Ang mga ito ay hindi madali. Nangangailangan sila ng emosyonal at teknikal na paghahanda. Nakakita ako kamakailan ng ilang malalaking listahan ng mga tanong sa panayam para sa mga posisyon ng developer ng Java. Ang mga tanong ay nahahati sa iba't ibang antas: junior, mid-level, at senior. Huwag mag-alala: hindi lahat ng tanong ay madali, ngunit ang mga may asterisk ay bihirang itanong. Maganda ang mga tanong, at gusto kong subukang sagutin ang karamihan sa mga ito. Maliwanag, hindi lahat ito ay magkakasya sa isang artikulo. Kung tutuusin, maraming tanong doon. Nangangahulugan iyon na magkakaroon ng isang buong serye ng mga artikulo na may mga sagot sa mga tanong na ito sa pakikipanayam. Hayaan akong bigyang-diin kaagad ang ilang mga punto: ang mga sagot ay maikli, dahil ang mga sagot na nakasulat nang detalyado ay maaaring makuha sa isang hiwalay na artikulo. Gayundin, sa mga panayam ay hindi kailangan ang mga sobrang detalyado at mabibigat na sagot, dahil ang iyong tagapanayam ay may isang oras lang para makapanayam ka sa mahahalagang paksa (at,

Q&A para sa isang junior developer position

Pangkalahatang tanong

1. Anong mga pattern ng disenyo ang alam mo? Sabihin sa amin ang tungkol sa dalawang pattern ng disenyo na ginamit mo sa iyong trabaho.

Mayroong isang malaking pagkakaiba-iba ng mga pattern. Para sa inyo na gustong lubusang maging pamilyar sa mga pattern ng disenyo, inirerekomenda kong basahin ang aklat na "Una ang ulo. Mga Pattern ng Disenyo". Makakatulong ito sa iyong madaling matutunan ang mga detalye ng pinakapangunahing mga pattern ng disenyo. Sa mga tuntunin ng mga pattern ng disenyo na maaari mong banggitin sa isang pakikipanayam sa trabaho, ang mga sumusunod ay naiisip:

• Tagabuo — isang madalas na ginagamit na template, isang alternatibo sa klasikong diskarte sa paggawa ng bagay;
• Diskarte — isang pattern na mahalagang kumakatawan sa polymorphism. Iyon ay, mayroon kaming isang interface, ngunit ang pag-uugali ng programa ay nagbabago depende sa partikular na pagpapatupad ng interface na ipinasa sa function (ang pattern ng diskarte ay ginagamit na ngayon sa halos lahat ng dako sa mga aplikasyon ng Java).

Kung hindi iyon sapat para sa iyo, bigyang-pansin ang Spring (kung pamilyar ka na dito), dahil ito ay isang buong platform ng mga balangkas, na, sa turn, ay natatakpan ng mga pattern mula simula hanggang katapusan. Narito ang ilang mga halimbawa ng kung ano ang pinag-uusapan ko:

• Factory — ang pattern na ito ay matatagpuan sa ApplicationContext (o sa BeanFactory);
• Singleton — lahat ng beans ay singleton bilang default;
• Proxy — karaniwang, lahat sa Spring ay gumagamit ng pattern na ito sa isang paraan o iba pa, halimbawa, AOP;
• Chain of responsibility — isang pattern na nagpapatibay sa Spring Security;
• Template — ginagamit sa Spring JDBC.

Java Core

2. Anong mga uri ng data ang mayroon sa Java?

Ang Java ay may mga sumusunod na primitive na uri ng data:

• byte — mga integer mula -128 hanggang 127, tumatagal ng hanggang 1 byte;
• maikli — mga integer mula -32768 hanggang 32767, tumatagal ng 2 byte;
• int — mga integer mula -2147483648 hanggang 2147483647, tumatagal ng hanggang 4 na byte;
• mahaba — mga integer mula 9223372036854775808 hanggang 9223372036854775807, tumatagal ng 8 byte;
• float — mga floating point na numero mula -3.4E+38 hanggang 3.4E+38, tumatagal ng 4 byte;
• doble — mga floating point na numero mula -1.7E+308 hanggang 1.7E+308, tumatagal ng 8 byte;
• char — mga solong character sa UTF-16, tumatagal ng 2 byte;
• boolean true/false value, tumatagal ng 1 byte.

At may mga reference na uri ng data na tumuturo sa mga bagay sa heap.

3. Paano naiiba ang isang bagay sa mga primitive na uri ng data?

Ang unang pagkakaiba ay ang dami ng memory na inookupahan: ang mga primitive ay kumukuha ng napakakaunting dahil naglalaman lamang ang mga ito ng kanilang sariling halaga, ngunit ang mga bagay ay maaaring maglaman ng maraming iba't ibang mga halaga - parehong mga primitive at mga sanggunian sa iba pang mga bagay. Ang pangalawang pagkakaiba ay ito: Ang Java ay isang object-oriented na wika, kaya lahat ng bagay sa Java ay gumagana ay isang pakikipag-ugnayan sa pagitan ng mga bagay. Ang mga primitive ay hindi masyadong magkasya dito. Sa katunayan, iyon ang dahilan kung bakit ang Java ay hindi isang 100% object-oriented na wika. Ang pangatlong pagkakaiba, na sumusunod mula sa pangalawa ay dahil ang Java ay nakatutok sa mga pakikipag-ugnayan ng bagay, mayroong maraming iba't ibang mga mekanismo para sa pamamahala ng mga bagay. Halimbawa, ang mga konstruktor, pamamaraan, eksepsiyon (na pangunahing gumagana sa mga bagay), atbp. At upang payagan ang mga primitive na kahit papaano ay gumana sa object-oriented na kapaligiran na ito, ang mga tagalikha ng Java ay nakaisip ngmga wrapper para sa mga primitive na uri ( Integer , Character , Double , Boolean ...)

4. Ano ang pagkakaiba sa pagitan ng pagpasa ng mga argumento sa pamamagitan ng sanggunian at sa pamamagitan ng halaga?

Ang mga primitive na field ay nag-iimbak ng kanilang halaga: halimbawa, kung itinakda namin ang int i = 9; , pagkatapos ay iniimbak ng i field ang value na 9. Kapag mayroon tayong reference sa isang object, ibig sabihin mayroon tayong field na may reference sa object. Sa madaling salita, mayroon kaming field na nag-iimbak ng address ng object sa memorya.

Cat cat = new Cat();

Nangangahulugan ito na ang mga patlang na may reference sa isang bagay ay nag-iimbak din ng mga halaga . Ang kanilang mga halaga ay mga address ng memorya. Iyon ay, iniimbak ng pusa ang memory address ng bagong Cat() object. Kapag nagpasa tayo ng argumento sa isang pamamaraan, ang halaga nito ay kinokopya. Sa kaso ng primitive, ang halaga ng primitive ay kinopya. Alinsunod dito, gumagana ang pamamaraan sa kopya. Kapag binago ang kopya, hindi maaapektuhan ang orihinal. Sa kaso ng isang uri ng sanggunian, ang halaga ng memory address ay kinokopya. Alinsunod dito, ang parehong mga reference na variable ay mag-iimbak ng mga address na tumuturo sa parehong bagay. At kung gagamitin natin ang bagong reference na ito upang baguhin ang object, makikita natin na binago din ito para sa lumang reference. Tutal, pareho silang tumuturo sa iisang bagay.

5. Ano ang JVM, JDK, at JRE?

Ang JVM ay kumakatawan sa Java Virtual Machine , na nagpapatakbo ng Java bytecode na paunang nabuo ng compiler. Ang JRE ay nangangahulugang Java Runtime Environment . Karaniwan, ito ay isang kapaligiran para sa pagpapatakbo ng mga aplikasyon ng Java. Kabilang dito ang JVM, karaniwang mga aklatan, at iba pang mga bahagi para sa pagpapatakbo ng mga applet at application na nakasulat sa Java programming language. Sa madaling salita, ang JRE ay isang pakete ng lahat ng kailangan para magpatakbo ng isang pinagsama-samang Java program, ngunit hindi ito kasama ang mga tool at utility gaya ng mga compiler o debugger para sa pagbuo ng mga application. Ang JDK ay nangangahulugang Java Development Kit , na isang extension ng JRE. Iyon ay, ito ay isang kapaligiran hindi lamang para sa pagpapatakbo ng mga aplikasyon ng Java, kundi pati na rin para sa pagbuo ng mga ito. Ang JDK ay naglalaman ng lahat ng bagay sa JRE, kasama ang iba't ibang karagdagang tool — mga compiler at debugger — na kailangan upang lumikha ng mga Java application (kabilang ang mga Java docs).

6. Bakit gagamitin ang JVM?

Gaya ng nakasaad sa itaas, ang Java Virtual Machine ay isang virtual machine na nagpapatakbo ng Java bytecode na paunang nabuo ng compiler. Nangangahulugan ito na hindi naiintindihan ng JVM ang source code ng Java. Kaya, una, nag-compile kami ng mga .java file. Ang mga pinagsama-samang file ay may .classextension at ngayon ay nasa anyo ng bytecode, na naiintindihan ng JVM. Ang JVM ay iba para sa bawat OS. Kapag ang JVM ay nagpapatakbo ng mga bytecode file, iniangkop nito ang mga ito para sa OS kung saan ito tumatakbo. Sa katunayan, dahil may iba't ibang JVM, ang JDK (o JRE) ay naiiba din para sa iba't ibang OS (ang bawat bersyon ay nangangailangan ng sarili nitong JVM). Tandaan natin kung paano gumagana ang development sa ibang mga programming language. Sumulat ka ng isang programa, pagkatapos ang code nito ay pinagsama-sama sa machine code para sa isang partikular na OS, at pagkatapos ay maaari mo itong patakbuhin. Sa madaling salita, kailangan mong magsulat ng iba't ibang bersyon ng programa para sa bawat platform. Ngunit ang dobleng pagpoproseso ng code ng Java (pagsasama-sama ng source code sa bytecode, at pagkatapos ay pagpoproseso ng bytecode ng JVM) ay hinahayaan kang tamasahin ang mga benepisyo ng isang cross-platform na solusyon. Lumilikha kami ng code nang isang beses at pinagsama-sama ito sa bytecode. Pagkatapos ay maaari naming dalhin ito sa anumang OS, at ang katutubong JVM ay magagawang patakbuhin ito. At ito ay tiyak na maalamat ng Javamagsulat ng isang beses, tumakbo kahit saan tampok.

7. Ano ang bytecode?

Tulad ng sinabi ko sa itaas, kino-convert ng compiler ang Java code sa intermediate bytecode (pumupunta kami mula sa mga file na may extension na .java patungo sa mga file na may extension na .class). Sa maraming paraan, ang bytecode ay katulad ng machine code, maliban na ang set ng pagtuturo nito ay hindi para sa isang tunay na processor, ngunit isang virtual. Iyon ay sinabi, maaari itong magsama ng mga seksyon na idinisenyo para sa isang JIT compiler, na nag-o-optimize ng command execution para sa aktwal na processor kung saan tumatakbo ang program. Ang JIT compilation, na tinatawag ding on-the-fly compilation, ay isang teknolohiya na nagpapataas ng performance ng bytecode program sa pamamagitan ng pag-compile ng bytecode sa machine code o ibang format habang tumatakbo ang program. Tulad ng maaaring nahulaan mo, ginagamit ng JVM ang JIT compiler kapag nagpapatakbo ito ng bytecode. Tingnan natin ang ilang sample na bytecode: Hindi masyadong nababasa, eh? Ang mabuting balita ay ang tagubiling ito ay hindi para sa atin. Ito ay para sa JVM.

8. Ano ang mga tampok ng isang JavaBean?

Ang JavaBean ay isang Java class na sumusunod sa ilang mga patakaran. Narito ang ilan sa mga patakaran para sa pagsulat ng JavaBean :

1. Ang klase ay dapat maglaman ng isang walang laman (no-argument) constructor na may pampublikong access modifier. Ginagawang posible ng tagabuo na ito na lumikha ng isang bagay ng klase nang walang anumang hindi kinakailangang mga problema (upang walang hindi kinakailangang kalikot sa mga argumento).

2. Ang mga panloob na field ay ina-access sa pamamagitan ng get at set instance method, na dapat ay may karaniwang pagpapatupad. Halimbawa, kung mayroon tayong field ng pangalan , dapat ay mayroon tayong getName at setName , atbp. Nagbibigay-daan ito sa iba't ibang tool (frameworks) na awtomatikong makuha at itakda ang nilalaman ng beans nang walang anumang kahirapan.

3. Dapat i-override ng klase ang equals() , hashCode() , at toString() na mga pamamaraan.

4. Ang klase ay dapat na serializable. Iyon ay, dapat itong magkaroon ng Serializable marker interface o ipatupad ang Externalizable interface. Ito ay upang ang estado ng bean ay mapagkakatiwalaang mai-save, maiimbak, at maibalik.

9. Ano ang OutOfMemoryError?

Ang OutOfMemoryError ay isang kritikal na runtime error na nauugnay sa Java Virtual Machine (JVM). Ang error na ito ay nangyayari kapag ang JVM ay hindi maaaring maglaan ng isang bagay dahil walang sapat na memorya para dito, at ang basurero ay hindi makakapaglaan ng mas maraming memorya. Ilang uri ng OutOfMemoryError :

• OutOfMemoryError: Java heap space — hindi mailalaan ang object sa Java heap dahil sa hindi sapat na memorya. Ang error na ito ay maaaring sanhi ng memory leak o ng default na laki ng heap na masyadong maliit para sa kasalukuyang application.

• OutOfMemoryError: Lumampas sa limitasyon ng GC Overhead — dahil halos hindi magkasya ang data ng application sa heap, tumatakbo sa lahat ng oras ang garbage collector, na nagiging sanhi ng pagtakbo ng Java program nang napakabagal. Bilang resulta, lumampas ang limitasyon sa overhead ng kolektor ng basura at nag-crash ang application sa error na ito.

• OutOfMemoryError: Ang hiniling na laki ng array ay lumampas sa limitasyon ng VM — ipinapahiwatig nito na sinubukan ng application na maglaan ng memory para sa isang array na lampas sa laki ng heap. Muli, ito ay maaaring mangahulugan na ang hindi sapat na memorya ay inilaan bilang default.

• OutOfMemoryError: Metaspace — naubusan ng espasyo ang heap na inilaan para sa metadata (ang metadata ay mga tagubilin para sa mga klase at pamamaraan).

• OutOfMemoryError: humiling ng laki ng mga byte para sa kadahilanan. Out of swap space — may naganap na error noong sinusubukang maglaan ng memory mula sa heap, at bilang resulta, ang heap ay kulang ng sapat na espasyo.

10. Ano ang stack trace? Paano ko ito makukuha?

Ang stack trace ay isang listahan ng mga klase at pamamaraan na tinawag hanggang sa puntong ito sa pagpapatupad ng isang application. Maaari mong makuha ang stack trace sa isang partikular na punto sa application sa pamamagitan ng paggawa nito:

StackTraceElement[] stackTraceElements =Thread.currentThread().getStackTrace();

Nagbibigay ito sa amin ng hanay ng mga StackTraceElement na nakaayos sa pagkakasunud-sunod ng Last In First Out (LIFO) . Sa Java, kapag pinag-uusapan ng mga tao ang tungkol sa isang stack trace, karaniwan nilang ibig sabihin ay isang stack trace na ipinapakita sa console kapag may naganap na error (o exception). Maaari mong makuha ang stack trace mula sa mga pagbubukod tulad nito:

StackTraceElement[] stackTraceElements;
try{
                ...
} catch (Exception e) {
   stackTraceElements = e.getStackTrace();
}

At kung gusto naming magpakita ng stack trace ng exception sa console:

try{
                ...
} catch (Exception e) {
  e.printStackTrace();
}

Bukod pa rito, kung may naganap na error, walang check na exception, o hindi nahawakang checked exception, awtomatiko naming makukuha ang stack trace ng exception sa console kapag nag-crash ang application. Narito ang isang maliit na halimbawa ng isang stack trace sa console: At sa tala na iyon, tatapusin natin ang ating pagtalakay sa paksang ito ngayon.