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

Hello, hello! Ang mga developer ng Java ay may malaking pangangailangan ngayon. Siyempre, hindi ako makapagbibigay sa iyo ng pagbubukas ng trabaho, ngunit susubukan kong tulungan kang makakuha ng ilang bagong kaalaman at punan ang ilang mga kakulangan. Kaya't ipagpatuloy natin ang aming pagsusuri sa mga tanong sa panayam ng developer ng Java. Makakakita ka ng mga link sa mga nakaraang bahagi ng pagsusuri sa dulo ng artikulo.

39. Ano ang mga access modifier sa Java? Pangalanan sila. Ano ang ginagamit ng mga ito?

Nauna kong sinaklaw ang mga modifier ng pag-access sa isang tanong tungkol sa mga elemento ng Java na ginamit upang makamit ang encapsulation. Ngunit gayon pa man, ipapaalala ko sa iyo. Ang mga modifier ng access sa Java ay mga keyword na naglalarawan sa antas ng access na ibinigay sa isang partikular na bahagi ng Java. Ang mga sumusunod na access modifier ay umiiral:

• pampubliko — isang elemento na minarkahan ng modifier na ito ay pampubliko. Sa madaling salita, ang mga patlang at pamamaraan, at mga klase na idineklara sa pampublikong modifier ay makikita ng ibang mga klase kapwa sa kanilang sariling pakete at sa mga panlabas na pakete;
• protektado — ang isang elementong minarkahan ng modifier na ito ay naa-access mula sa kahit saan sa sarili nitong klase sa kasalukuyang package o nagmula na mga klase, kahit na nasa ibang mga pakete ang mga ito;
• default (o walang modifier sa lahat) implicitly nalalapat kapag walang access modifier ay ipinahiwatig. Ito ay katulad ng nauna, maliban na ito ay makikita sa mga nagmula na klase na matatagpuan sa iba pang mga pakete;
• pribado — ito ang pinakapribado sa lahat ng mga modifier. Pinapayagan nito ang pag-access sa isang elemento sa loob lamang ng kasalukuyang klase.

40. Pangalanan ang mga pangunahing katangian ng static at non-static na pamamaraan

Ang pangunahing pagkakaiba ay ang mga static na pamamaraan ay kabilang sa isang klase. Sa katunayan, hindi mo kailangang lumikha ng isang instance ng klase na ito - ang mga static na pamamaraan ay maaaring tawagin mula lamang sa uri ng klase. Halimbawa, ipagpalagay na mayroon kaming isang static na paraan para sa pag-aalaga sa isang pusa:

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Pet the cat: " + cat.getName());
   }

Hindi namin kailangan ng isang instance ng klase ng CatService para tawagan ito:

Cat cat = new Cat(7, "Bobby");
CatService.petTheCat(cat);

Sa kabaligtaran, ang mga ordinaryong pamamaraan ay nakatali (pag-aari) sa isang bagay. Upang tawagan sila, dapat ay mayroon kang isang instance (object) kung saan tatawagin ang pamamaraan. Halimbawa, ipagpalagay na ang aming pusa ay may non-static na pamamaraan na meow() :

class Cat {
   public void meow() {
       System.out.println("Meow! Meow! Meow!");
   }

Upang tawagan ang paraang ito, kailangan namin ng isang partikular na halimbawa ng isang pusa:

Cat cat = new Cat(7, "Bobby");
cat.meow();

41. Ano ang mga pangunahing paghihigpit na nalalapat sa mga static at non-static na pamamaraan?

Tulad ng sinabi ko kanina, ang pangunahing limitasyon ng isang ordinaryong (non-static) na pamamaraan ay dapat palaging mayroong ilang pagkakataon kung saan tinawag ang pamamaraan. Ngunit ang isang static na pamamaraan ay hindi nangangailangan nito. Bukod pa rito, hindi magagamit ng isang static na pamamaraan ang sanggunian na ito sa mga elemento ng isang bagay dahil mayroon na ngayong kasalukuyang bagay para sa pamamaraan.

42. Ano ang ibig sabihin ng static na keyword? Maaari bang ma-override o ma-overload ang isang static na paraan?

Ang isang elementong minarkahan ng static na keyword ay hindi kabilang sa isang instance ng isang klase kundi sa klase mismo. Ito ay na-load kapag ang klase mismo ay na-load. Ang mga static na elemento ay pareho para sa buong programa, habang ang mga hindi static na elemento ay pareho lamang para sa isang partikular na bagay. Ang mga sumusunod na elemento ay maaaring static:

• larangan ng isang klase;
• bloke ng pagsisimula ng isang klase;
• isang paraan ng isang klase;
• mga nested na klase ng isang klase (siyempre, ito rin ay isang tautolohiya).

Ang isang static na pamamaraan ay hindi maaaring ma-override: ito ay kabilang sa klase at hindi minana, ngunit sa parehong oras, maaari itong ma-overload.

43. Maaari bang maging static at abstract sa parehong oras ang isang pamamaraan?

Nasagot ko na ito sa isang nakaraang artikulo: ang isang pamamaraan ay hindi maaaring abstract at static sa parehong oras. Kung abstract ang isang paraan, nangangahulugan iyon na dapat itong i-override sa isang klase ng bata. Ngunit ang isang static na pamamaraan ay kabilang sa klase, at hindi ito maaaring ma-override. Lumilikha ito ng isang kontradiksyon, na mapapansin ng tagatala at magalit. Kung makikita mo ang iyong sarili sa sitwasyong ito, dapat mong seryosong isipin ang kawastuhan ng arkitektura ng iyong aplikasyon (pahiwatig: may malinaw na mali dito).

44. Maaari bang gamitin ang mga static na pamamaraan sa gitna ng mga non-static na pamamaraan? At vice versa? Bakit?

Maaari tayong gumamit ng mga static na pamamaraan sa mga non-static na pamamaraan. Walang pumipigil diyan. Iyon ay sinabi, ang kabaligtaran ay hindi posible: ang isang static na pamamaraan ay hindi maaaring gumamit ng isang non-static na pamamaraan nang hindi tumutukoy sa isang partikular na halimbawa ng klase. Tandaan, ang mga static na miyembro ng isang klase ay walang access sa isang sanggunian na ito : maaari kang magkaroon ng maraming kongkretong bagay ng klase hangga't gusto mo, at bawat isa sa kanila ay naglalaman ng isang sanggunian na ito , na isang self-reference. Kaya paano matukoy kung aling sanggunian na ito ang gagamitin? Uh, ayaw mo. Iyon ang dahilan kung bakit ang mga static na elemento ay hindi maaaring sumangguni sa mga hindi static na walang sanggunian sa isang partikular na bagay. Karaniwan, ang isang static na pamamaraan ay maaaring gumamit ng isang non-static na pamamaraan kung ito ay may reference sa isang partikular na bagay. Halimbawa, isa na dumating bilang argumento ng pamamaraan:

public static void petTheCat(Cat cat) {
   System.out.println("Pet the cat: " + cat.getName());
}

Dito makikita natin na sa static na petTheCat() method ay tumatawag sa getName , isang ordinaryong non-static na paraan ng isang Cat object.

45. Ano ang isang interface? Maaari bang magkaroon ng panghuling interface?

Matatandaan namin na ang Java ay walang maramihang mana. Ang mga interface ay isang bagay na kahalili dito. Ang isang interface ay parang isang napaka-strip na klase. Tinutukoy nila ang functionality ngunit hindi isang kongkretong pagpapatupad. Ang gawaing iyon ay naiwan sa mga klase na nagpapatupad ng mga interface na ito. Halimbawa ng isang interface:

public interface Animal {
    void speak();
}

Halimbawa ng pagpapatupad ng interface ng isang klase

class Cat implements Animal {

   @Override
   public void speak() {
       System.out.println("Meow! Meow! Meow!");
   }
}

Narito ang mahalagang pangunahing bagay na dapat malaman tungkol sa paggamit ng mga interface:

1. Ang mga pamamaraan ng interface ay dapat lamang maglaman ng isang header. Hindi sila dapat magkaroon ng isang partikular na katawan ng pamamaraan, ibig sabihin, dapat silang abstract (bagaman hindi nila ginagamit ang abstract na keyword). May mga pagbubukod: mga static na pamamaraan at mga default na pamamaraan, na nangangailangan ng katawan ng pamamaraan.

2. Ang isang klase ay maaaring magpatupad ng maraming mga interface (tulad ng sinabi ko, ang mga interface ay isang alternatibo sa maramihang pamana). Ang mga pangalan ng interface ay pinaghihiwalay ng mga kuwit sa header ng pamamaraan: ipinapatupad ng class Lion ang Animal, Wild .

3. Ang mga interface ay nilikha gamit ang interface na keyword.

4. Kapag ang isang klase ay nagpapatupad ng isang interface, ginagamit namin ang ipinapatupad na keyword.

5. Ang isang klase na nagpapatupad ng isang partikular na interface ay dapat magpatupad ng lahat ng abstract na pamamaraan nito, o dapat magdeklara ng sarili nitong abstract.

6. Ang pangunahing layunin ng paggamit ng mga interface ay upang ipatupad ang polymorphism (upang bigyan ang isang bagay ng kakayahang kumuha ng maraming anyo).

7. Bilang isang panuntunan, ang mga modifier ng access para sa mga pamamaraan ay hindi ipinahiwatig sa mga interface: ang mga ito ay pampubliko bilang default, at hindi mo maaaring tukuyin ang mga modifier maliban sa pampubliko . Simula sa Java 9, maaari kang gumamit ng mga pribadong modifier sa mga pamamaraan.

8. Bilang default, ang mga variable ng interface ay static final . Sa madaling salita, ang mga ito ay mga pare-pareho — dapat silang palaging nasimulan nang direkta sa interface.

9. Hindi ka makakagawa ng isang instance ng isang interface.

Ang sagot sa tanong kung ang mga interface ay maaaring maging pangwakas ay, siyempre, hindi. Sa katunayan, ang buong punto ng pagkakaroon ng mga interface ay para ipatupad ang mga ito. At gaya ng naaalala nating lahat, ang panghuling modifier sa antas ng klase ay ginagawang hindi mamanahin ang isang klase, at sa kaso ng isang interface — hindi maipapatupad. Bakit kailangan namin ng isang interface na hindi namin maaaring ipatupad at gamitin? Tama ka — hindi namin gagawin! At sumasang-ayon ang compiler. :) Sa totoo lang, sa pagpapakilala ng mga static na pamamaraan ng interface mula noong Java 8, maaaring mayroong isang punto, ngunit hindi nito binabago ang katotohanan na ang isang interface ay hindi maaaring maging pangwakas. Napag-usapan ko lang ang tungkol sa mga interface nang napakababaw, dahil ito ay isang malawak na paksa. Para sa higit pa tungkol dito, tingnan ang mga artikulo sa mga interface sa Java at ang pagkakaiba sa pagitan ng mga abstract na klase at mga interface .

46. ​​Saan maaaring simulan ang mga static na field?

Maaaring masimulan ang mga static na field:

• kaagad pagkatapos ng deklarasyon, gamit ang isang katumbas na tanda ( = );
• sa isang static na initialization block;
• sa isang non-static na initialization block (ngunit kailangan mong maunawaan na sa tuwing may gagawing object, ang static na field ay ma-overwrite kapag ang initialization block na ito ay naisakatuparan;
• sa isang tagabuo ng klase. Sa tuwing tatawagin ang constructor (iyon ay, sa bawat oras na nilikha ang isang bagay gamit ang constructor na ito), ang field ay ma-overwrite;
• sa mga static na pamamaraan;
• sa mga non-static na pamamaraan;
• sa mga nested na static at non-static, lokal, at anonymous na mga klase.

47. Ano ang mga anonymous na klase?

Ang mga anonymous na klase ay mga klase na walang sariling uri. Ano bang pinagsasabi ko? Nang usapan natin ang tungkol sa mga interface, binanggit ko na hindi ka makakagawa ng isang halimbawa ng isang bagay: maaari ka lamang lumikha ng isang halimbawa ng isang klase na nagpapatupad ng isang interface. Paano kung hindi mo nais ang ilang klase na magpatupad ng isang interface ngunit kailangan ng isang bagay na nagpapatupad ng interface? At ito ay malamang na ang tanging gamit ng bagay. At wala kang anumang pangangailangan upang lumikha ng isang ganap na klase ng pagpapatupad. Paano mo ito gagawin? Tama iyan! Sa pamamagitan ng paggamit ng anonymous na klase! Ipagpalagay na mayroon kaming ilang interface ng Animal :

public final interface Animal {
   public void speak();
}

Kung gusto naming gumamit ng anonymous na klase upang i-instantiate ang isang naibigay na interface:

Animal cat = new Animal() {
   @Override
   public void speak() {
       System.out.println("Meow! Meow! Meow!");
   }
};

At pagkatapos, maaari mong ligtas na gamitin ang bagay na ito at ang ipinatupad nitong speak() na pamamaraan. Sa madaling salita, ipinapatupad ng anonymous na klase ang interface at lahat ng abstract na pamamaraan nito, dito mismo at ngayon. Kung hindi, hindi kami makakagawa ng isang interface/abstract class object dahil magkakaroon ng mga hindi naipatupad/abstract na pamamaraan. Tulad ng nabanggit ko, ang mga hindi kilalang klase ay ginagamit hindi lamang upang ipatupad ang mga abstract na pamamaraan ng isang interface kundi pati na rin upang ipatupad ang mga abstract na pamamaraan ng isang abstract na klase. Ang diskarte na ito ay mabuti para sa mga sitwasyon kapag ang isang bagay ay ginamit nang isang beses o kapag ang isang ibinigay na pagpapatupad ng pamamaraan ay kinakailangan nang isang beses lamang. Hindi na kailangang lumikha ng isang hiwalay na klase na magpapatupad ng kinakailangang abstract na klase/interface. Ngunit napapansin ko rin na ang mga anonymous na klase ay bihirang ginagamit sa trabaho. Bilang isang patakaran, ang mga ordinaryong klase ay binibigyan pa rin ng kagustuhan. Maaari kang magbasa ng higit pa tungkol sa mga hindi kilalang klase dito sa artikulong ito .

48. Ano ang mga primitive na klase?

Sa tingin ko ito ay isang mapanlinlang na tanong, posibleng isang trick na tanong, dahil ang Java ay walang bagay na primitive na klase. Mayroon lamang ang konsepto ng mga primitive na uri, na isinasaalang-alang namin dati. Naaalala namin na ang Java ay may 8 primitive na uri: byte , short , int , long , float , double , char , boolean .

49. Ano ang klase ng wrapper?

Ang pangunahing problema sa paggamit ng mga primitive na uri sa Java ay hindi sila mga klase, at ang Java ay isang wikang OOP. Iyon ay, ang mga programang nakasulat sa wikang ito ay katumbas ng mga pakikipag-ugnayan sa pagitan ng mga bagay. Ngunit ang mga primitive ay hindi mga bagay. Wala silang mga pamamaraan, kahit na ang mga karaniwang pamamaraan ng klase ng Bagay . Ngunit paano kung kailangan nating gumamit ng primitive bilang susi sa isang Map ? Pagkatapos ay kailangan nating tawagan ang hashCode() na pamamaraan nito. Maaari mo ring tawagan ang equals() na pamamaraan doon. Ano ngayon? May mga oodles at oodles ng mga sandali kung saan kailangan mo ng isang klase, hindi isang primitive. Ginagawa nitong hindi nagagamit at hindi kanais-nais na mga elemento ang mga primitive sa isang programa dahil nilalabag nila ang mismong ideya ng OOP. Ngunit ang sitwasyon ay hindi kasing sama ng tila. Pagkatapos ng lahat, ang Java ay may konsepto ng mga primitive wrapper. Sa Java, ang bawat primitive na uri ay may kambal — isang klase ng wrapper.

• byte -> Byte.class
• maikli -> Maikli.klase
• int -> Integer.class
• mahaba -> Mahaba.klase
• lumutang -> Lutang.klase
• doble -> Doble.klase
• char -> Character.class
• boolean -> Boolean.class

Ang mga uri na ito ay kumakatawan sa mga simpleng uri, ngunit sa mga ganap na klase na may isang grupo ng iba't-ibang at kapaki-pakinabang na mga pamamaraan. Ang mga konsepto ng autoboxing at unboxing ay ipinakilala upang payagan ang mga klase na ito na magamit nang maginhawa. Ang Autoboxing ay ang awtomatikong pag-convert ng isang primitive na uri sa katulad nitong klase, kung kinakailangan (halimbawa, pag-convert ng int sa Integer ). Ang pag-unbox ay ang kabaligtaran na proseso: awtomatikong pag-convert ng isang primitive na klase ng wrapper sa isang primitive na uri (halimbawa, pag-convert ng Integer sa int ). Salamat sa pagpapakilala ng mga primitive na klase ng wrapper at ang mga proseso ng autoboxing at unboxing , ang mga primitive na uri ay ganap na ngayong miyembro ng Java bilang isang wikang OOP. Para sa mas malalim na talakayan sa paksang ito, lubos kong inirerekumenda na basahin ang artikulong ito .

50. Ano ang nested class? Saan ito ginagamit?

Ang nested class ay isang klase na mismong miyembro ng isa pang klase. Mayroong 4 na uri ng mga nested class na ito sa Java: 1. Inner class Ang ganitong uri ng klase ay direktang idineklara sa katawan ng ibang klase. Ang inner class ay isang non-static na nested class at maaaring ma-access ang anumang pribadong field o instance na paraan ng outer class. Bilang halimbawa, gumawa tayo ng zoo na naglalaman ng hayop — isang zebra:

public class Zoo {
   class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

Hindi kumplikado, tama? Tingnan natin ang isang halimbawa ng paglikha ng isang halimbawa ng panloob na klase:

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.eat("apple");

Tulad ng nakita mo na, kinakailangan muna na lumikha ng isang bagay ng kalakip na klase. Pagkatapos ay gagamitin mo ang object reference upang lumikha ng isang instance ng inner class. Gusto ko ring ituro na ang isang panloob na klase (non-static na nested class) ay hindi maaaring magkaroon ng mga static na pamamaraan o static na mga field. Ito ay tiyak dahil ang panloob na klase ay tahasang nauugnay sa isang halimbawa ng panlabas na uri nito, at samakatuwid ay hindi maaaring magpahayag ng anumang mga static na pamamaraan sa loob mismo. 2. Static nested classes Ang mga klase ay katulad ng nakaraang kategorya, ngunit mayroon silang static na access modifier sa deklarasyon ng klase. Dahil ang ganitong uri ng klase ay walang access sa mga non-static na field ng outer class, mas mukhang static na bahagi ito ng outer class kaysa sa inner class. Ngunit ang klase na ito ay may access sa lahat ng mga static na miyembro ng panlabas na klase, kahit na ang mga pribado. Halimbawa ng isang static na nested na klase:

public class Zoo {
   static class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

Ito ay nilikha sa isang bahagyang naiiba mula sa nauna:

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.eat("apple");

Dito hindi namin kailangan ng object ng outer class para lumikha ng object ng static nested class. Kailangan lang nating malaman ang pangalan ng nested class para mahanap ito sa loob ng outer class. 3. Mga lokal na klase Ang mga lokal na klase ay mga klase na idineklara sa loob ng katawan ng isang pamamaraan. Ang mga bagay ng isang lokal na klase ay maaaring malikha at magamit lamang sa loob ng nakapaloob na pamamaraan. Halimbawa:

public class Zoo {
   public void feed(String animal, String food) {
       switch(animal) {
           case "zebra":
               class Zebra {
                   public void eat(String food) {
                       System.out.println("Zebra eats " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.eat(food);
               ...

Narito ang isang halimbawa:

Zoo zoo = new Zoo();
zoo.feed("zebra", "apple");

Kung hindi mo nakita ang code para sa feed() na paraan, hindi ka maghihinala na may lokal na klase, hindi ba? Ang isang lokal na klase ay hindi maaaring maging static o transient , ngunit maaari itong markahan bilang abstract o final (isa O ang isa pa, ngunit hindi pareho, dahil ang sabay-sabay na paggamit sa dalawang modifier na ito ay lumilikha ng isang salungatan). 4. Anonymous na mga klase Napag-usapan na natin ang tungkol sa mga anonymous na klase sa itaas, at tulad ng maaalala mo, maaari silang malikha mula sa dalawang mapagkukunan — mga interface at klase. Ang mga dahilan para gamitin ang mga ito ay ginagamit ang mga nested na static at non-static na klase dahil minsan mas mainam na mag-embed ng maliliit na klase sa mas pangkalahatan at panatilihing magkasama ang mga ito para magkaroon sila ng mas mataas na pagkakaisa at isang karaniwang layunin. Karaniwan, hinahayaan ka ng mga nested na klase na pataasin ang encapsulation ng iyong code. Maaari mong piliing gumamit ng lokal na klase kung ang klase ay ginagamit lamang sa loob ng iisang pamamaraan. Sa kasong ito, kailangan ba nating ikalat ang code sa application? Hindi. Iyon ay sinabi, idaragdag ko na sa aking karanasan ay hindi pa ako nakakita ng sinumang gumamit ng mga lokal na klase, dahil kung kailangan man sila o hindi ay lubos na kontrobersyal. Maaari kang gumamit ng mga hindi kilalang klase kapag ang isang partikular na pagpapatupad ng isang interface o isang abstract na klase ay kailangan lang nang isang beses. Sa kasong iyon, hindi na kailangang lumikha ng isang hiwalay, ganap na klase na may pagpapatupad. Sa halip, pinananatili namin itong simple at ipinatupad ang (mga) pamamaraan na kailangan namin gamit ang isang hindi kilalang klase, ginamit ang bagay, at pagkatapos ay nakalimutan ang tungkol dito (siyempre, hindi nakalimutan ng kolektor ng basura). Ang iyong pag-unawa sa mga nested na klase ay mapapahusay ng artikulo dito.

51. Anong mga access modifier ang maaaring magkaroon ng isang klase?

Mayroong iba't ibang uri ng mga klase at iba't ibang access modifier ang nalalapat sa kanila:

• ang isang panlabas na klase ay maaaring magkaroon ng pampublikong access modifier o walang modifier (ang default na modifier);
• ang isang panloob na klase (non-static na nested class) ay maaaring magkaroon ng alinman sa 4 na access modifier;
• ang isang nested static na klase ay maaaring magkaroon ng alinman sa mga access modifier maliban sa protektado dahil ang modifier na ito ay nagpapahiwatig ng mana, na sumasalungat sa sinumang static na miyembro ng klase (static na mga miyembro ay hindi minana);
• ang isang lokal na klase ay maaari lamang magkaroon ng default na modifier (ibig sabihin, walang modifier sa lahat);
• ang isang anonymous na klase ay walang deklarasyon ng klase, kaya wala itong access modifier.

Dito na tayo magtatapos para sa araw na ito. Hanggang sa muli!