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

Kamusta! Nagtipon ang iba't ibang tao sa JavaRush. Gusto lang ng ilan sa atin na maging mga developer ng Java, namumuhunan ng maraming oras at pagsisikap sa pag-unlad, habang ang iba ay mga developer na ng Java. Sa isang kaso o iba pa, kailangan mong maging handa para sa mga pagsubok - mga teknikal na panayam. Ang pagsusulit na ito ay hindi madali, at bilang karagdagan sa moral na paghahanda, kailangan din ang teknikal na paghahanda. Nakatagpo ako kamakailan ng isang malaking listahan ng Mga Tanong sa Panayam ng Developer ng Java sa dou. Ang mga tanong na ito ay nahahati sa iba't ibang antas - Junior, Middle at Senior. Huwag mag-alala: hindi lahat ng tanong ay madali, ngunit ang mga may asterisk ay bihirang itanong. Maganda ang mga tanong, ngunit gusto kong subukang sagutin ang karamihan sa mga ito. Malinaw na hindi ako pupunta sa saklaw ng isang artikulo; pagkatapos ng lahat, mayroong maraming mga katanungan doon. Samakatuwid, ito ay isang buong serye ng mga artikulo na sumasagot sa mga naturang katanungan. Hayaan akong agad na bigyang-diin ang ilang mga punto:

1. Mayroong isang mahusay na artikulo na may nangungunang mga tanong at sagot para sa kanila. Nag-o-overlap ang ilang tanong sa listahang ipinakita sa itaas (250+), kaya lalaktawan ang mga tanong na ito para hindi na muling ma-duplicate ang impormasyon.

2. Ang mga tanong ay iniharap sa Ukrainian, ngunit dahil ang karamihan sa mga kalahok ng JavaRush ay nagsasalita ng Ruso (at sa mas malaking lawak din ako), ang mga sagot ay nasa Russian.

3. Ang mga sagot ay maikli, dahil kung susulat ka nang detalyado, ang mga sagot sa ilang tanong ay maaaring mangailangan ng isang hiwalay na artikulo. At sa panahon ng mga panayam, hindi kailangan ang ganoong detalyado at mabibigat na mga sagot, dahil ang iyong tagapanayam ay mayroon lamang isang oras upang makapanayam ka sa mga kinakailangang paksa (at, tulad ng naaalala mo, sapat na iyon). Para sa mga gustong maghukay ng mas malalim, mag-iiwan ako ng mga link.

Kaya, magsimula tayo.

Mga Tanong at Sagot sa Junior Level

Pangkalahatang isyu

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

Mayroong isang malaking iba't ibang mga template: maaari kang magsimulang makilala ang mga ito mula dito at sa artikulong ito. Buweno, para sa iyo na gustong maging pamilyar sa kanila nang detalyado, inirerekumenda kong basahin ang aklat na "Una ang Ulo. Mga Pattern ng Disenyo" . Sa tulong nito, maaari mong pag-aralan ang pinakapangunahing mga pattern ng disenyo nang detalyado at sa madaling paraan. Pagdating sa mga pattern ng disenyo na maaari mong gamitin bilang mga halimbawa sa isang panayam, ang ilan sa mga naiisip ay:

• Ang Builder ay isang madalas na ginagamit na template, isang alternatibo sa paglikha ng klasikong bagay;
• Pattern ng diskarte , na likas na kumakatawan sa polymorphism. Iyon ay, mayroon kaming isang interface, ngunit ang pag-uugali ng programa ay magbabago depende sa kung anong partikular na pagpapatupad ng interface na ito ang inilipat sa pag-andar (ngayon ang diskarte ay halos ginagamit sa lahat ng dako sa mga aplikasyon ng java).

Kung ito ay hindi sapat para sa iyo, bigyang-pansin ang Spring (kung pamilyar ka na dito), dahil ito ay isang buong platform ng mga balangkas, na kung saan ay puno ng mga pattern pataas at pababa. Narito ang ilang mga halimbawa ng kung ano ang pinag-uusapan ko:

• Pabrika - sa ApplicationContext (o sa BeanFactory);
• Singleton - lahat ng beans ay singleton bilang default;
• Proxy - mahalagang lahat sa tagsibol ay gumagamit ng pattern na ito sa isang paraan o iba pa, halimbawa, AOP;
• Ang chain of responsibility ay isang pattern batay sa konsepto kung saan gumagana ang Spring Security;
• Template - ginamit sa Spring Jdbc.

Java Core

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

Ang Java ay may mga primitive na uri ng data:

• byte — mga integer sa hanay -128 hanggang 127, may timbang na 1 byte;
• maikli — mga integer sa hanay -32768 hanggang 32767, may timbang na 2 byte;
• int — integers -2147483648 hanggang 2147483647, may timbang na 4 bytes;
• mahaba — mga integer sa hanay na 9223372036854775808 hanggang 9223372036854775807, tumitimbang ng 8 byte;
• float — mga floating point na numero sa hanay na -3.4E+38 hanggang 3.4E+38, may timbang na 4 byte;
• double — mga floating point na numero sa hanay na -1.7E+308 hanggang 1.7E+308, may timbang na 8 byte;
• char — mga solong character sa UTF-16, may timbang na 2 byte;
• boolean values ​​​​true/false , tumitimbang ng 1 byte.

At reference ang mga 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: ang dami ng memorya na inookupahan: ang mga primitive ay kumukuha ng napakakaunting, dahil naglalaman lamang sila ng kanilang sariling halaga, habang ang mga bagay ay maaaring maglaman ng napakaraming iba't ibang mga halaga: parehong mga primitive at mga sanggunian sa iba pang mga bagay. Ang pangalawang pagkakaiba: Ang Java ay isang object-oriented na wika, kaya lahat ng bagay dito ay gumagana sa pamamagitan ng pakikipag-ugnayan sa pagitan ng mga bagay, at ang mga primitive ay hindi magkasya nang maayos (sa katunayan, ito ang dahilan kung bakit ang Java ay hindi isang 100% object-oriented na wika). Ikatlo, kasunod mula sa pangalawa: dahil ang Java ay nakatuon sa pakikipag-ugnayan sa pagitan ng mga bagay, ang mga bagay na ito ay may maraming iba't ibang mekanismo para sa pamamahala sa mga ito. Halimbawa, ang mga konstruktor, pamamaraan, mga pagbubukod (na pangunahing gumagana sa mga bagay), atbp. Sa totoo lang, upang ang mga primitive ay kahit papaano ay makasali (magtrabaho) sa object-oriented na kapaligiran na ito, ang mga wrapper ay naimbento para sa mga primitive na uri ( Integer , Character , Double , Boolean ...)

4. Ano ang pagkakaiba sa pagitan ng pagpasa ng mga parameter ayon sa sanggunian at ayon sa halaga?

Ang mga primitive na field ay nag-iimbak ng kanilang halaga: halimbawa, kung itinakda namin ang int i = 9; field i store ang value 9 . Kapag mayroon tayong reference sa isang bagay, nangangahulugan ito na mayroon tayong field na may reference sa object, o sa madaling salita, na may halaga ng address ng object sa memorya.

Cat cat = new Cat();

Lumalabas na ang mga patlang na may reference sa isang bagay ay nag-iimbak din ng mga halaga , mga halaga ng address ng memorya. Iyon ay, iniimbak ng pusa ang halaga ng address ng bagong bagay na Cat() sa memorya. Kapag ipinasa namin ang isang parameter sa isang pamamaraan, ang halaga nito ay kinokopya. Sa kaso ng primitive, ang halaga ng primitive ay makokopya. Alinsunod dito, gagana ang pamamaraan sa isang kopya, na nagbabago na hindi makakaapekto sa orihinal. Sa kaso ng isang uri ng sanggunian, ang halaga ng memory address ay makokopya, ayon sa pagkakabanggit, ang address ay magiging kapareho ng bagay na itinuturo nito. At kung babaguhin natin ang bagay gamit ang bagong link na ito, babaguhin ito para sa luma (pagkatapos ng lahat, pareho silang tumuturo sa parehong bagay).

5. Ano ang JVM, JDK, JRE?

JVM - Ang Java Virtual Machine ay isang virtual machine na nagpapatakbo ng Java bytecode na paunang nabuo ng compiler. Ang JRE - Java Runtime Environment - ay mahalagang kapaligiran para sa pagpapatakbo ng mga Java application, na naglalaman ng JVM , mga karaniwang aklatan at iba pang 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 pinagsama-samang Java program, ngunit hindi naglalaman ng mga tool at utility gaya ng mga compiler o debugger para sa pagbuo ng application. JDK - Java Development Kit - isang pinahabang hanay ng JRE , iyon ay, isang kapaligiran hindi lamang para sa paglulunsad, kundi pati na rin para sa pagbuo ng mga aplikasyon ng Java. Ang JDK ay naglalaman ng lahat ng nasa JRE, kasama ang iba't ibang karagdagang mga tool - mga compiler at debugger na kailangan upang lumikha ng mga application sa Java (naglalaman din ng mga java docs).

6. Bakit gumamit ng JVM?

Tulad ng nabanggit sa itaas, ang Java Virtual Machine ay isang virtual machine na nagpapatakbo ng Java bytecode na paunang nabuo ng compiler. Ibig sabihin, hindi naiintindihan ng JVM ang source code ng Java. Samakatuwid, una, ang mga .java file ay pinagsama-sama , na pagkatapos ng compilation ay mayroon nang .class na extension at ipinakita sa anyo ng parehong byte code na naiintindihan ng JVM. Ang bawat OS ay may sariling JVM, kaya sa pagtanggap ng mga bytecode file, ipapatupad ito ng JVM, iniangkop ito sa OS kung saan ito nangyayari. Sa totoo lang, dahil sa iba't ibang mga JVM, naiiba ang mga bersyon ng JDK (o JRE) para sa iba't ibang mga OS (ang bawat isa sa kanila ay nangangailangan ng sarili nitong JVM). Tandaan natin kung paano gumagana ang development sa ibang mga programming language. Bumuo 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 system. Samantalang sa Java, salamat sa dual code processing (compilation at processing ng JVM code bytes), masisiyahan ka sa mga benepisyo ng cross-platform. Minsan naming ginawa ang code, muling pinagsama-sama ito sa bytecode, inilipat ito sa anumang OS, at ang lokal na JVM ang nagpapatakbo ng code. Ito ang maalamat na pag-aari ng Java - sumulat nang isang beses, tumakbo kahit saan . Magbasa nang higit pa tungkol dito sa artikulong " Pag-compile at pag-execute ng mga Java application sa ilalim ng hood ."

7. Ano ang bytecode?

Tulad ng sinabi ko sa itaas, ang compiler ay nagko-convert ng Java code sa intermediate bytecode (mga file na may .java extension sa mga file na may .class na extension). Ang Bytecode sa maraming paraan ay katulad ng machine code, gumagamit lamang ito ng isang set ng mga tagubilin hindi mula sa isang tunay na processor, ngunit mula sa isang virtual. Bukod dito, maaari itong magsama ng mga seksyon na nakatuon sa paggamit ng isang JIT compiler, na nag-o-optimize sa pagpapatupad ng mga utos para sa tunay na processor kung saan tumatakbo ang programa. Ang JIT compilation, na tinatawag ding on-the-fly compilation, ay isang teknolohiya na nagpapataas ng performance ng isang program gamit ang bytecode sa pamamagitan ng pag-compile ng bytecode sa isang machine o iba pang format habang tumatakbo ang program. Tulad ng maaaring nahulaan mo, ang JVM ay gumagamit ng JIT compiler kapag nagpapatakbo ito ng bytecode. Tingnan natin ang isang halimbawa ng bytecode: Hindi masyadong nababasa, di ba? Well, ito ay hindi isang pagtuturo para sa amin, ngunit para sa JVM. Narito ang isang artikulo na tutulong sa iyo na mas maunawaan ang isyung ito.

8. Ano ang mga katangian ng isang JavaBean?

Ang JavaBeans ay isang klase ng Java na may ilang mga patakaran. Narito ang ilang mga patakaran para sa pagsulat ng isang JavaBean :

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

2. Ang mga panloob na field ng isang klase ay ina-access sa pamamagitan ng get at set method , na dapat ay standard. Halimbawa, kung ang field ay name , pagkatapos ay getName at setName, atbp. Ito naman, ay nagbibigay-daan sa iba't ibang tool (frameworks) na awtomatikong matukoy at ma-update ang mga nilalaman ng beans nang walang mga komplikasyon.

3. Ang klase ay dapat maglaman ng mga overridden na bersyon ng equals() method hashCode() at toString() .

4. Ang klase ay dapat na serializable, ibig sabihin, dapat itong may marker interface - Serializable o ipatupad ang Externalizable interface . Ito ay kinakailangan upang ang estado ng bean ay mapagkakatiwalaan na mai-save, maiimbak at maibalik.

Maaari mong basahin ang tungkol sa mga uri ng JavaBeans sa materyal na ito .

9. Ano ang OutOfMemoryError?

Ang OutOfMemoryError ay isa sa mga kritikal na runtime error na nauugnay sa pagpapatakbo ng Java Virtual Machine (JVM). Tinatawag kapag ang JVM ay hindi maaaring maglaan ng isang bagay dahil walang sapat na memorya na magagamit para dito at ang kolektor ng basura ay hindi maaaring maglaan ng higit pang memorya. Ilang uri ng OutOfMemoryError :

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

• OutOfMemoryError: Lumampas sa limitasyon ng GC Overhead - dahil sa katotohanan na ang dami ng data ay halos hindi magkasya sa heap, tumatakbo ang basurero sa lahat ng oras, at ang Java program ay tumatakbo nang napakabagal, at bilang resulta, ang overhead na limitasyon ng basurero. ay lumampas at nag-crash ang application sa error na ito.

• OutOfMemoryError: Ang hiniling na laki ng array ay lumampas sa limitasyon ng VM - nagpapahiwatig na sinubukan ng application na maglaan ng memory para sa isang array na mas malaki kaysa sa laki ng heap, na maaaring dahil sa hindi sapat na default na paglalaan ng memorya.

• OutOfMemoryError: Metaspace —naubusan na 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 kabiguan noong sinusubukang maglaan ng memorya mula sa heap at, bilang resulta, nagkaroon ng kakulangan ng memory sa heap.

10. Ano ang stack trace? Paano ito makukuha?

Ang Stack Trace ay isang listahan ng mga klase at pamamaraan na tinawag hanggang sa puntong ito sa application. Maaari kang tumawag ng stack trace sa isang partikular na punto sa application tulad nito:

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

Sa ganitong paraan makakakuha tayo ng hanay ng mga stack trace elements na nakaayos sa LIFO order - Last In First Out . Sa Java, bilang panuntunan, kapag pinag-uusapan natin ang tungkol sa stack trace, ang ibig sabihin ay ang stack trace na ipinapakita sa console kapag may naganap na error (o exception). Makukuha mo ang stack trace ng mga exception tulad nito:

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

Well, kung pinag-uusapan natin ang pag-output ng exception stack trace sa console:

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

Gayundin, kung mayroon kaming error, walang check na exception o may check na exception , na hindi namin ipoproseso, ngunit ipapasa lang, pagkatapos ay kapag nag-crash ang application ay awtomatiko kaming makakatanggap ng stack trace ng mga exception sa console. Isang maliit na halimbawa ng pagbubukod ng stack trace sa console: Maaari kang magbasa nang higit pa tungkol sa Stack Trace dito . Pagtutuunan natin ng pansin ang isyung ito ngayon...