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

Practice o teorya? Ano ang mas mahalaga? Maraming tao ang natural na magsasabi na ang pagsasanay ay mas mahalaga. Like, practice hanggang sa lumubog ang araw at magiging masaya ka. Maglalakas-loob akong hindi sumang-ayon dito. Sa panahon ng mga panayam, walang makakaalam kung gaano ka kagaling kapag nagsasanay ka. Sa halip, hihilingin sa iyo na ipakita ang iyong mga theory chops. Ito ay hindi hanggang mamaya kapag nalampasan mo na ang lahat ng mga layer ng mga panayam at na-assign sa isang proyekto, na ilalapat mo ang iyong mga praktikal na kasanayan. Maaari kang tumutol, na sinasabi kung minsan ay binibigyan ka nila ng isang gawain sa pagsusulit, kaya kailangan pa rin ang pagsasanay. Hindi ako sumasang-ayon, ngunit ang punto ko ay ito ay MINSAN, ngunit LAGING kailangan mong ipakita ang kaalaman sa teorya sa isang pakikipanayam. Nararamdaman mo ba ang pagkakaiba? Ang lahat ng ito ay nangangahulugan na kailangan mong magkaroon ng isang matatag na teoretikal na pundasyon sa ilalim ng iyong mga paa, at iyon ang patuloy naming itatayo ngayon. Higit na partikular, patuloy nating titingnan ang mga tanong na madalas itanong sa mga panayam.

71. Ano ang mangyayari kung hindi namin i-override ang toString() na paraan ng Enum?

Ipagpalagay na mayroon kaming sumusunod na enum :

public enum Role {
   STUDENT,
   TEACHER,
   DIRECTOR,
   SECURITY_GUARD;
}

Ipakita natin ang field ng STUDENT sa console sa pamamagitan ng pagtawag sa toString() method nito:

System.out.println(Role.STUDENT.toString());

Bilang resulta, nakukuha namin ang sumusunod na output ng console: Kaya, nakikita natin na para sa isang enum , ang default na pagpapatupad ng toString() ay nagbabalik ng pangalan ng constant mismo.

72. Maaari ka bang magdeklara ng isang constructor sa loob ng isang Enum?

Oo naman. Ang constructor ay kung ano ang nagtatakda ng mga halaga ng mga panloob na field ng enum . Bilang halimbawa, magdagdag tayo ng dalawang field sa nakaraang enum ( ageFrom at ageTo ) upang isaad ang hanay ng edad para sa bawat tungkulin:

public enum Role {
   STUDENT(5,18),
   TEACHER(20,60),
   DIRECTOR(40,70),
   SECURITY_GUARD(18,50);

   int ageFrom;
   int ageTo;

   Role(int ageFrom, int ageTo) {
       this.ageFrom = ageFrom;
       this.ageTo = ageTo;
   }
}

73. Ano ang pagkakaiba ng == at equals()?

Isa ito sa mga pinakakaraniwang tanong sa panayam na itinatanong sa mga magiging developer ng Java. Upang magsimula, kapag naghahambing ng mga simpleng halaga ( int , char , double ...), ginagamit namin ang == , dahil ang mga variable na ito ay naglalaman ng mga konkretong halaga na maaaring direktang ikumpara. Higit pa rito, ang mga primitive na variable ay hindi ganap na mga bagay — hindi nila namana ang klase ng Object at walang equals() na pamamaraan. Kung pinag-uusapan natin ang paghahambing ng mga variable na tumutukoy sa mga bagay, kailangan nating malaman na ang == ay inihahambing lamang ang halaga ng mga sanggunian, ibig sabihin, kung ang mga ito ay tumutukoy sa parehong bagay o hindi. Kahit na ang lahat ng data sa isang bagay ay magkapareho sa lahat ng data sa isa pa, ang paggamit ng == para sa isang paghahambing ay magbubunga ng negatibong resulta ( false ), dahil sila ay magkahiwalay na mga bagay. Tulad ng nahulaan mo na, ginagamit namin ang equals() na paraan upang ihambing ang mga reference na variable. Ito ay isa sa mga karaniwang pamamaraan ng klase ng Bagay , at kinakailangan para sa isang ganap na paghahambing ng mga bagay. Ngunit kailangan kong sabihin kaagad na upang gumana nang tama ang pamamaraang ito, dapat itong i-override upang ipahiwatig nang eksakto kung paano dapat ihambing ang mga bagay. Kung hindi mo i-override ang pamamaraan, makukuha mo ang default na pagpapatupad, na naghahambing sa mga bagay gamit ang == . Sa IntelliJ IDEA, maaari mo itong awtomatikong i-override gamit ang isang shortcut ng IDEA: Alt+Insert . Sa lalabas na window, piliin ang equals() at hashCode() . Pagkatapos ay piliin ang mga patlang na dapat kasangkot. Voila! Ang mga pamamaraan ay awtomatikong ipinatupad. Narito ang isang halimbawa kung paano hinahanap ng isang awtomatikong nabuong equals method ang pinakasimpleng posibleng klase ng Cat na may dalawang field — int age at String name :

@Override
public boolean equals(final Object o) {
   if (this == o) return true;
   if (o == null || this.getClass() != o.getClass()) return false;
   final Cat cat = (Cat) o;
   return this.age == cat.age &&
           Objects.equals(this.name, cat.name);
}

Pagdating sa enum , walang praktikal na pagkakaiba sa pagitan ng == at equals() . Pagkatapos ng lahat, ang isang enum ay nag-iimbak ng mga pare-pareho, at kahit na maghambing tayo ng magkaparehong mga halaga gamit ang == , makakakuha tayo ng true , dahil ang mga pinaghambing na sanggunian ay palaging tumuturo sa parehong mga bagay. At ang paggamit ng equals() ay nakakakuha rin ng tamang resulta. Kung pupunta ka sa katawan ng equals method para sa Enum , makikita mo na ang Enum class ay may sumusunod na pagpapatupad: Sa loob ay makikita natin ang isang magandang lumang paghahambing ng mga sanggunian! Upang buod, para sa enum s, maaari nating ihambing nang tama gamit ang parehong == at equals() .

74. Ano ang ginagawa ng ordinal() na pamamaraan ng Enum?

Kapag tinawag namin ang int ordinal() na pamamaraan sa isang enum field, nakukuha namin ang zero-based na index ng field sa listahan ng mga halaga ng enum. Tawagan natin ang pamamaraang ito sa isang patlang sa Role enum, na dati nating isinasaalang-alang:

System.out.println(Role.DIRECTOR.ordinal());

Alinsunod dito, ipinapakita ng console ang:

75. Magagamit ba ang Enum sa TreeSet o TreeMap sa Java?

Maaari naming gamitin ang mga uri ng enum sa TreeSet at TreeMap . At maaari nating isulat ito:

TreeSet<Role> treeSet = new TreeSet<>();
treeSet.add(Role.SECURITY_GUARD);
treeSet.add(Role.DIRECTOR);
treeSet.add(Role.TEACHER);
treeSet.add(Role.STUDENT);
treeSet.forEach(System.out::println);

At ipapakita ng console: Nakuha namin ang output, ngunit hindi ayon sa alpabeto. Ang punto ay kung gagamit tayo ng mga field ng enum bilang mga halaga ng TreeSet o bilang mga key ng TreeMap , ang mga patlang ay pinagsunod-sunod sa kanilang natural na pagkakasunud-sunod (sa pagkakasunud-sunod kung saan sila ay tinukoy sa enum ). Ang pag-unawa na ito ay kung paano ito gumagana ay tumutulong sa amin na magsulat ng mas mahusay na code.

76. Paano nauugnay ang mga pamamaraan ng ordinal() at compareTo() ng Enum?

Gaya ng nabanggit kanina, ibinabalik ng ordinal() ang index ng field sa listahan ng mga enum field. Gayundin, sa aming pagsasaalang-alang sa nakaraang tanong, nakita mo na kapag ang mga patlang ng enum ay inilagay sa isang TreeSet (na isang pinagsunod-sunod na hanay), kinukuha nila ang pagkakasunud-sunod kung saan ang mga ito ay ipinahayag sa enum . At tulad ng alam natin, ang TreeSet at TreeMap ay nag-uuri ng mga item sa pamamagitan ng pagtawag sa compareTo() na paraan ng kanilang Comparable interface. Sinasabi nito sa amin na ang klase ng Enum ay nagpapatupad ng Comparable interface, na nangangahulugang ipinapatupad nito ang compareTo() na paraan, na panloob na gumagamit ng ordinal() na pamamaraan upang matukoy ang pagkakasunud-sunod. Pagpunta sa klase ng Enum , maaari naming kumpirmahin ang aming palagay: At narito ang katawan ng pamamaraan mismo: Ang ordinal() na pamamaraan ay hindi tinatawag dito. Sa halip, ginagamit ang ordinal variable, na siyang index number ng elemento sa enumeration. Ang ordinal() na pamamaraan mismo ay hindi hihigit sa isang getter para sa ordinal na variable.

77. Sumulat ng isang halimbawa ng Enum

Sa mga tanong na tinalakay sa itaas, nakapagbigay na ako ng mga halimbawa ng enum s. Wala akong nakikitang dahilan para i-duplicate ang code dito. Halimbawa, tingnan ang Tanong 72 tungkol sa isang constructor sa isang enum.

78. Maaari bang gamitin ang isang Enum sa isang switch case?

Ito ay maaaring at dapat na! Sa pagtingin sa aking karanasan, mapapansin ko na ang isa sa mga pinakakaraniwang gamit ng enum ay sa mga lohikal na konstruksyon tulad ng mga pahayag ng switch . Sa kasong ito, maaari mong ibigay ang lahat ng posibleng kaso s — sa sandaling isulat mo ang lohika para sa bawat field ng enum , hindi mo na kailangan ng default na sugnay! Pagkatapos ng lahat, kung gumagamit ka ng String o isang numeric na halaga, tulad ng isang int , maaari kang makatanggap ng hindi inaasahang halaga, ngunit imposible iyon sa isang enum . Narito ang magiging hitsura ng switch statement para sa halimbawa sa itaas:

public void doSomething(Role role) {
   switch (role) {
       case STUDENT:
           // some logic for STUDENT
           break;
       case TEACHER:
           // some logic for TEACHER
           break;
       case DIRECTOR:
           // some logic for DIRECTOR
           break;
       case SECURITY_GUARD:
           // some logic for SECURITY_GUARD
           break;
   }
}

79. Paano ko makukuha ang lahat ng posibleng halaga ng isang Enum?

Kung kailangan mong makuha ang lahat ng posibleng enum value, mayroong values() method, na nagbabalik ng array ng lahat ng posibleng value para sa enum sa kanilang natural na pagkakasunud-sunod (iyon ay, sa pagkakasunud-sunod kung saan ang mga ito ay tinukoy sa enum ). Halimbawa:

Role[] roles = Role.values();
for (Role role : roles) {
   System.out.println(role);
}

Magkakaroon kami ng mga sumusunod sa console:

Stream API

80. Ano ang Stream sa Java?

Ang Java Stream API ay isang medyo bagong paraan ng pakikipag-ugnayan sa isang stream ng data, na nagbibigay-daan sa amin na mas maginhawa at maayos na magproseso ng malaking data, gayundin ang magproseso ng data nang magkatulad sa ilang bilang ng mga stream, na posibleng mapalakas ang pagganap.

81. Pangalanan ang mga pangunahing katangian ng mga transaksyon

Ang paksa dito ay ang Stream API, ngunit ang tanong ay tungkol sa mga transaksyon. Hmm... Una, unawain natin kung ano ang isang transaksyon. Ang isang transaksyon ay isang pangkat ng mga sunud-sunod na operasyon sa isang database. Ito ay kumakatawan sa isang lohikal na yunit ng trabaho. Ang isang transaksyon ay maaaring maisakatuparan nang hiwalay sa iba pang kasabay na mga transaksyon nang buo at matagumpay, sa gayon ay pinapanatili ang integridad ng data, o hindi naisasagawa, kung saan wala itong epekto. Ang mga transaksyon ay may apat na pangunahing katangian, na madali nating matandaan salamat sa acronym na ACID . Tingnan natin kung ano ang ibig sabihin ng bawat titik ng acronym na ito: A ay nangangahulugang Atomicity . Ginagarantiyahan ng property na ito na walang transaksyon na bahagyang ginawa sa system. Alinman sa lahat ng mga suboperasyon nito ay isasagawa, o wala sa mga ito ang isasagawa ( lahat o wala ). Ang С ay nangangahulugang Consistency . Ginagarantiyahan ng property na ito na ang bawat matagumpay na transaksyon ay gagawa lamang ng mga wastong resulta. Sa madaling salita, ito ay isang garantiya na kung ang transaksyon ay matagumpay, ang lahat ng mga patakaran ng system para sa partikular na data ay masusunod. Kung ang transaksyon ay hindi matagumpay, hindi ito isasagawa at ang data ng system ay babalik sa dati nitong estado. Naninindigan ako para sa Isolation . Ang pag-aari na ito ay nangangahulugan na kapag ang isang transaksyon ay naisakatuparan, ang mga kasabay na transaksyon ay hindi dapat makaapekto sa kinalabasan nito. Ang pag-aari na ito ay masinsinang mapagkukunan, kaya, bilang isang panuntunan, ito ay bahagyang ipinatupad, na nagpapahintulot sa ilang mga antas ng paghihiwalay na lumulutas ng mga partikular na problema sa paghihiwalay. Tatalakayin natin ito nang mas detalyado sa susunod na tanong. D ay nangangahulugang Durability . Ginagarantiyahan ng property na ito na kung makatanggap ang user ng kumpirmasyon na nakumpleto ang transaksyon, makatitiyak siya na hindi makakansela ang mga pagbabago dahil sa ilang pagkabigo. Ibig sabihin, makakasigurado kang walang magagawa ang ilang operating system failure sa iyong data kung nakatanggap ka na ng kumpirmasyon na matagumpay na natapos ang iyong transaksyon.

82. Ano ang mga antas ng paghihiwalay ng transaksyon?

Gaya ng sinabi ko kanina, pagdating sa mga katangian ng ACID, ang pagtiyak na ang paghihiwalay ay isang prosesong masinsinang mapagkukunan. Alinsunod dito, ang ari-arian na ito ay bahagyang ipinatupad. Mayroong iba't ibang antas ng paghihiwalay: mas mataas ang antas, mas matindi ang epekto sa pagganap. Bago tayo magpatuloy sa mga antas ng paghihiwalay ng transaksyon, kailangan nating isaalang-alang ang iba't ibang problema na nangyayari dahil sa hindi sapat na paghihiwalay ng transaksyon :

• phantom reads : kapag ang parehong kahilingan, na tinawag nang higit sa isang beses sa loob ng isang transaksyon, ay nagbubunga ng iba't ibang resulta dahil sa mga pagpapasok ng isa pang transaksyon;

• nonrepeatable reads : kapag ang parehong kahilingan, na tinawag nang higit sa isang beses sa loob ng isang transaksyon, ay nagbubunga ng iba't ibang data dahil sa mga pagbabago (mga update) at mga pagtanggal ng isa pang transaksyon;

• dirty reads : pagbabasa ng data na hindi pa nakasaad na idinagdag o binago ng isang transaksyon at pagkatapos ay ibinalik;

• nawalang mga update : kapag ang isang bloke ng data ay sabay-sabay na binago ng iba't ibang mga transaksyon, at lahat ng mga pagbabago maliban sa huli ay nawala (katulad ng isang kondisyon ng lahi sa multithreading).

Habang nangyayari ito, ang mga antas ng paghihiwalay ng transaksyon ay nailalarawan sa kung anong mga problema sa paghihiwalay ang kanilang pinoprotektahan. Isaalang-alang ang sumusunod na talahanayan ng mga antas ng paghihiwalay at ang mga problemang pinoprotektahan nila laban sa: At huwag kalimutan ang flip side: kung mas mataas ang antas ng paghihiwalay, mas matagal na proseso ang mga transaksyon (ibinigay parallel execution ng maramihang mga transaksyon).

83. Ano ang pagkakaiba sa pagitan ng isang Statement at isang PreparedStatement?

Dito kami ay biglang nagbago ng paglipat sa mga tampok ng JDBC . Sa anumang pangyayari, alamin muna natin kung tungkol saan ang isang Pahayag . Ito ay isang bagay na ginagamit upang bumuo ng mga query sa SQL. Gumagamit ang JDBC ng tatlong uri: Statement , PreparedStatement , at CallableStatement . Hindi namin isasaalang-alang ang CallableStatement ngayon. Sa halip, pinag-uusapan natin ang pagkakaiba sa pagitan ng Statement at PreparedStatement .

1. Ginagamit ang pahayag upang magsagawa ng mga simpleng query sa SQL nang walang mga parameter ng pag-input ng runtime. Maaaring tanggapin ng PrepareStatement ang mga parameter ng input sa runtime.

2. Upang magtakda ng mga parameter para sa PreparedStatement , ang mga parameter ng input ay isinusulat bilang mga tandang pananong sa kahilingan, upang mapalitan sila ng ilang halaga gamit ang iba't ibang setter, tulad ng setDouble() , setFloat() , setInt() , setTime() ... Ito nangangahulugan na hindi ka maglalagay ng maling uri ng data sa kahilingan.

3. PreparedStatement ay precompiled at gumagamit ng caching, kaya maaari itong maisakatuparan nang mas mabilis kaysa sa isang kahilingan na ginawa ng mga object ng Statement . Bilang resulta, ang mga SQL statement na madalas na isinasagawa ay nilikha bilang mga bagay na PreparedStatement upang mapabuti ang pagganap.

4. Ang pahayag ay mahina sa SQL injection, ngunit pinipigilan sila ng PreparedStatement.

At kasama niyan, tatawagin natin itong isang araw!