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

Hoy lahat! Ang programming ay puno ng mga pitfalls. At halos walang isang paksa na hindi magiging sanhi ng iyong pagkatisod at pag-utot ng iyong daliri. Ito ay totoo lalo na para sa mga nagsisimula. Ang tanging paraan upang mailigtas ang iyong mga daliri sa paa ay ang matuto. Sa partikular, kailangan mong sumisid nang malalim sa mga pinakapangunahing paksa. Ngayon, ipagpapatuloy namin ang pagsusuri ng mga pinakasikat na tanong sa panahon ng mga panayam para sa mga developer ng Java. Ang mga tanong sa panayam na ito ay gumagawa ng isang mahusay na trabaho sa pagsakop sa mga pangunahing paksa. Tandaan na kasama rin sa listahan ang ilang hindi gaanong karaniwang mga tanong na nagbibigay-daan sa iyong lapitan ang mga karaniwang isyu sa ibang paraan.

62. Ano ang string pool, at bakit ito kailangan?

Ang bahagi ng memory na ginawang magagamit sa isang Java program ay tinatawag na heap (na pag-uusapan natin mamaya), at ang bahagi ng heap ay tinatawag na String pool . Ito ay para sa pag-iimbak ng mga halaga ng string. Sa madaling salita, kapag lumikha ka ng isang string, halimbawa, gamit ang mga dobleng panipi tulad nito:

String str = "Hello world";

Sinusuri ng JVM kung ang string pool ay mayroon nang tinukoy na halaga. Kung gagawin nito, ang str variable ay itatalaga ng isang reference sa value na iyon sa pool. Kung hindi, isang bagong value ang gagawin sa pool, at isang reference dito ay itatalaga sa str variable. Isaalang-alang natin ang isang halimbawa:

String firstStr = "Hello world";
String secondStr = "Hello world";
System.out.println(firstStr == secondStr);

true ay ipapakita sa screen. Tandaan na ang == ay naghahambing ng mga sanggunian, at ang dalawang variable na ito ay tumuturo sa parehong halaga sa string pool. Nakakatulong ito upang maiwasan ang paggawa ng maraming magkakaparehong String object sa memorya. Magagawa namin ito dahil, gaya ng maaalala mo, ang String ay isang hindi nababagong klase, kaya walang mali sa pagkakaroon ng maraming reference sa parehong halaga. Ngayon ay imposibleng magkaroon ng isang sitwasyon kung saan ang pagbabago ng halaga sa isang lugar ay nagreresulta sa mga pagbabago sa ilang iba pang mga sanggunian. Gayunpaman, kung lumikha kami ng isang string gamit ang bago :

String str = new String("Hello world");

pagkatapos ay ang isang hiwalay na bagay ay nilikha sa memorya at iniimbak ang tinukoy na halaga ng string (hindi mahalaga kung ang halagang iyon ay nasa string pool na). Upang kumpirmahin ang assertion na ito, isaalang-alang ito:

String firstStr = new String("Hello world");
String secondStr = "Hello world";
String thirdStr = new String("Hello world");
System.out.println(firstStr == secondStr);
System.out.println(firstStr == thirdStr);

Makakakuha kami ng dalawang linya na nagpapahiwatig ng false , na nangangahulugan na mayroon kaming tatlong magkahiwalay na mga string. Karaniwan, ito ang dahilan kung bakit dapat kang lumikha ng mga string gamit lamang ang double-quotes. Sabi nga, posibleng magdagdag (o makakuha ng reference sa) mga value sa string pool kahit na gumagawa ng object gamit ang bagong keyword. Para magawa ito, ginagamit namin ang intern() method ng String class . Tinitiyak ng paraang ito na gagawin namin ang value sa string pool o makakakuha kami ng reference dito kung naroon na ito. Narito ang isang halimbawa:

String firstStr = new String("Hello world").intern();
String secondStr = "Hello world";
String thirdStr = new String("Hello world").intern();
System.out.println(firstStr == secondStr);
System.out.println(firstStr == thirdStr);
System.out.println(secondStr == thirdStr);

Ang code na ito ay naglalabas ng totoo sa console nang tatlong beses, na nagsasabi sa amin na ang lahat ng tatlong mga variable ay tumutukoy sa parehong string sa memorya.

63. Anong mga pattern ng disenyo ng GoF ang ginagamit sa string pool?

Sa string pool, ang pattern ng disenyo ng GoF ay isang pattern ng flyweight . Kung napansin mo ang isa pang pattern ng disenyo dito, ibahagi ito sa mga komento. Dito natin pag-uusapan ang pattern ng disenyo ng flyweight. Ito ay isang structural design pattern kung saan ang isang object na kumakatawan sa sarili nito bilang isang natatanging instance sa iba't ibang lugar sa program ay talagang hindi kakaiba. Ang flyweight ay nagse-save ng memorya sa pamamagitan ng pag-iimbak ng nakabahaging estado ng mga bagay sa halip na mag-imbak ng magkaparehong data sa bawat bagay. Upang maunawaan ang diwa, isaalang-alang ang elementarya na halimbawang ito. Sabihin nating mayroon tayong interface ng Empleyado :

public interface Employee {
   void work();
}

At mayroon itong ilang mga pagpapatupad, tulad ng klase ng Abogado :

public class Lawyer implements Employee {

   public Lawyer() {
       System.out.println("A lawyer was hired.");
   }

   @Override
   public void work() {
       System.out.println("Settling legal issues...");
   }
}

At isang klase ng Accountant :

public class Accountant implements Employee {

   public Accountant() {
       System.out.println("An accountant was hired.");
   }

   @Override
   public void work() {
       System.out.println("Keeping accounting records...");
   }
}

Ang mga pamamaraan ay ganap na arbitrary — para sa halimbawang ito, kailangan lang nating makita na ang mga ito ay isinasagawa. Ang parehong ay totoo tungkol sa constructor. Sinasabi sa amin ng output ng console kung kailan nilikha ang mga bagong bagay. Mayroon din kaming departamento ng human resources na ang gawain ay ibalik ang hiniling na empleyado. Kung ang empleyadong iyon ay wala pa sa kawani, pagkatapos ay tatanggapin sila at ibabalik ng departamento ng HR ang bagong empleyado:

public class HumanResourcesDepartment {
   private Map<String, Employee> currentEmployees = new HashMap<>();

   public Employee getEmployee(String type) throws Exception {
       Employee result;
       if (currentEmployees.containsKey(type)) {
           result = currentEmployees.get(type);
       } else {
           switch (type) {
               case "Accountant":
                   result = new Accountant();
                   currentEmployees.put(type, result);
                   break;
               case "Lawyer":
                   result = new Lawyer();
                   currentEmployees.put(type, result);
                   break;
               default:
                   throw new Exception("This employee is not on the staff!");
           }
       }
       return result;
   }
}

Kaya, ang lohika ay simple: kung ang nais na bagay ay umiiral, ibalik ito; kung hindi, likhain ito, ilagay ito sa imbakan (tulad ng isang cache), at ibalik ito. Ngayon tingnan natin kung paano gumagana ang lahat:

public static void main(String[] args) throws Exception {
   HumanResourcesDepartment humanResourcesDepartment = new HumanResourcesDepartment();
   Employee empl1 = humanResourcesDepartment.getEmployee("Lawyer");
   empl1.work();
   Employee empl2 = humanResourcesDepartment.getEmployee("Accountant");
   empl2.work();
   Employee empl3 = humanResourcesDepartment.getEmployee("Lawyer");
   empl1.work();
   Employee empl4 = humanResourcesDepartment.getEmployee("Accountant");
   empl2.work();
   Employee empl5 = humanResourcesDepartment.getEmployee("Lawyer");
   empl1.work();
   Employee empl6 = humanResourcesDepartment.getEmployee("Accountant");
   empl2.work();
   Employee empl7 = humanResourcesDepartment.getEmployee("Lawyer");
   empl1.work();
   Employee empl8 = humanResourcesDepartment.getEmployee("Accountant");
   empl2.work();
   Employee empl9 = humanResourcesDepartment.getEmployee("Lawyer");
   empl1.work();
   Employee empl10 = humanResourcesDepartment.getEmployee("Accountant");
   empl2.work();
}

Narito ang makikita natin sa console: Tulad ng nakikita mo, gumawa lamang kami ng dalawang bagay at ginamit muli ang mga ito nang maraming beses. Napakasimple ng halimbawa, ngunit ipinapakita nito kung paano mapangalagaan ng pattern ng disenyo na ito ang aming mga mapagkukunan. Tulad ng maaaring napansin mo, ang lohika ng pattern na ito ay masakit na katulad ng lohika ng isang pool ng seguro.

64. Paano natin hinahati ang isang string sa mga bahagi? Magbigay ng halimbawa ng nauugnay na code

Malinaw, ang tanong na ito ay tungkol sa split method. Ang String class ay may dalawang variation ng pamamaraang ito:

String split(String regex);

at

String split(String regex);

Ang regex parameter ay ang delimiter — ilang regular na expression na ginagamit upang hatiin ang string sa isang hanay ng mga string, halimbawa:

String str = "Hello, world it's Amigo!";
String[] arr = str.split("\\s");
for (String s : arr) {
  System.out.println(s);
}

Ipapakita ng console ang: Kaya, ang aming string ay nahati sa isang hanay ng mga string, gamit ang isang puwang bilang delimiter (sa halip na ang regular na expression "\\s" , maaari rin naming gamitin ang ordinaryong string na expression " " ). Ang pangalawa, overloaded na variant, ay may karagdagang parameter ng limitasyon . Ang limitasyon ay ang maximum na pinapayagang laki ng resultang array. Sa madaling salita, kapag nahati na ang string sa maximum na pinapayagang bilang ng mga substring, hihinto ang paghahati, at maglalaman ang huling elemento ng anumang "mga natira" mula sa posibleng hindi nahati na string. Halimbawa:

String str = "Hello, world it's Amigo!";
String[] arr = str.split(" ", 2);
for (String s : arr) {
  System.out.println(s);
}

Output ng console: Tulad ng nakikita natin, kung hindi para sa limit = 2 , ang huling elemento ng array ay maaaring hatiin sa tatlong substrings.

65. Bakit mas mahusay ang array ng character kaysa sa string para sa pag-iimbak ng password?

Mayroong ilang mga dahilan para mas gusto ang isang array kaysa sa isang string kapag nag-iimbak ng password:

1. Ang string pool at string immutability.

Kapag gumagamit ng array ( char[] ), maaari naming tahasang burahin ang data kapag tapos na kaming magtrabaho dito. Maaari rin naming i-overwrite ang array hangga't gusto namin, na inaalis ang password mula sa system kahit bago ang koleksyon ng basura (sapat na baguhin ang ilang mga cell sa mga di-wastong halaga). Sa kabaligtaran, ang String ay isang hindi nababagong klase. Nangangahulugan ito na kung gusto nating baguhin ang halaga ng isang String object, makakakuha tayo ng bago, ngunit ang luma ay mananatili sa string pool. Kung gusto naming tanggalin ang String na naglalaman ng password, nahaharap kami sa isang kumplikadong gawain dahil kailangan namin ng garbage collector upang alisin ang value na iyon mula sa string pool, ngunit ang String na iyon ay malamang na mananatili doon sa mahabang panahon. Iyon ay, pagdating sa ligtas na pag-iimbak ng data, ang String ay mas mababa sa isang char array.

2. Kung ilalabas natin ang String value sa console (o isang log), makukuha natin ang:

String password = "password";
System.out.println("Password - " + password);

Output ng console: At kung mangyari mong i-print ang array sa console:

char[] arr = new char[]{'p','a','s','s','w','o','r','d'};
System.out.println("Password - " + arr);

magpapakita ang console ng hindi maintindihang kalokohan: Sa katunayan, hindi ito kadaldalan. Narito kung paano maunawaan ang iyong nakikita: [C ang pangalan ng klase - char array, @ ay isang delimiter, at pagkatapos ay ang 7f31245a ay isang hexadecimal hash code.

3. Ang opisyal na Java Cryptography Architecture (JCA) Reference Guide ay tahasang binanggit ang pag-iimbak ng mga password sa isang char[] sa halip na isang String :

"Mukhang lohikal na kolektahin at iimbak ang password sa isang bagay na may uri na java.lang.String . Gayunpaman, narito ang caveat: Ang mga bagay na may uri ng String ay hindi nababago, ibig sabihin, walang mga pamamaraan na tinukoy na nagpapahintulot sa iyo na baguhin (patungan) o i-zero out ang mga nilalaman ng isang String pagkatapos ng paggamit. Ginagawa ng feature na ito na hindi angkop ang mga String object para sa pag-iimbak ng impormasyong sensitibo sa seguridad gaya ng mga password ng user. Sa halip, dapat kang palaging mangolekta at mag-imbak ng impormasyong sensitibo sa seguridad sa isang char array."

Enum

66. Magbigay ng maikling paglalarawan ng Enum sa Java

Ang enum ay maikli para sa enumeration, na isang hanay ng mga string constant na pinagsama ng isang karaniwang uri. Ipinapahayag namin ang isa gamit ang enum keyword. Narito ang isang halimbawa na may enum : mga pinahihintulutang tungkulin sa ilang campus ng paaralan:

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

Ang mga salitang nakasulat sa malalaking titik ay ang enumeration constants. Ang mga ito ay ipinahayag sa isang pinasimple na paraan, nang walang bagong operator. Ang paggamit ng mga enumerasyon ay ginagawang mas madali ang buhay dahil nakakatulong ang mga ito na maiwasan ang mga pagkakamali at pagkalito sa mga pangalan (dahil ang listahan ay tumutukoy sa tanging wastong mga halaga). Para sa akin, napaka-convenient nila sa switch construct.

67. Maaari bang magpatupad ang isang Enum ng mga interface (gamitin ang keyword na ipinapatupad)?

Oo. Pagkatapos ng lahat, ang mga enum ay dapat na kumakatawan sa higit pa sa mga passive set (tulad ng mga tungkulin sa isang campus ng paaralan). Sa Java, maaari silang kumatawan sa mas kumplikadong mga bagay, kaya maaaring kailanganin mong magdagdag ng karagdagang pag-andar sa mga ito. Nagbibigay-daan din ito sa iyo na samantalahin ang polymorphism sa pamamagitan ng pagpapalit sa halaga ng enum sa mga lugar kung saan kailangan ang ipinatupad na uri ng interface.

68. Maaari bang palawigin ng Enum ang isang klase (gamitin ang extends na keyword)?

Hindi, hindi pwede, dahil ang enum ay isang subclass ng default na Enum<T> class, kung saan ang T ay ang uri ng enum. Ito ay hindi hihigit sa isang karaniwang base class para sa lahat ng uri ng enum sa wikang Java. Ang conversion mula sa isang enum sa isang klase ay ginagawa ng Java compiler sa oras ng pag-compile. Ang extension ay hindi tahasang ipinahiwatig sa code, ngunit ito ay palaging ipinahiwatig.

69. Posible bang lumikha ng isang Enum nang walang anumang mga pagkakataon ng mga bagay?

Ang tanong na ito ay medyo nakakalito, at hindi ako sigurado na lubos ko itong naiintindihan. Mayroon akong dalawang interpretasyon: 1. Maaari ka bang magkaroon ng enum nang walang anumang halaga? Oo, siyempre, ngunit ito ay magiging tulad ng isang walang laman na klase - walang kabuluhan, hal

public enum Role {
}

At kung tatawagan natin:

var s = Role.values();
System.out.println(s);

Nakukuha namin ang sumusunod sa console: (isang walang laman na hanay ng mga halaga ng Tungkulin ) 2. Posible bang gumawa ng enum nang walang bagong operator? Oo naman. Tulad ng sinabi ko sa itaas, hindi mo ginagamit ang bagong operator para sa mga halaga ng enum, dahil ang mga ito ay mga static na halaga.

70. Maaari ba nating i-override ang toString() na paraan ng Enum?

Oo, siyempre maaari mong i-override ang toString() na paraan upang tukuyin kung paano ipapakita ang iyong enum kapag tinawag ang toString na paraan (kapag nagko-convert ng isang enum sa isang ordinaryong string, halimbawa, upang i-output ito sa console o mga log).

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

   @Override
   public String toString() {
       return "Selected role - " + super.toString();
   }
}

Iyon lang para sa akin ngayon. Hanggang sa susunod na bahagi!