สำรวจคำถามและคำตอบจากการสัมภาษณ์งานสำหรับตำแหน่ง Java Developer ส่วนที่ 2

สวัสดีอีกครั้งนะทุกคน! เรายังคงค้นหาคำตอบสำหรับคำถามสำหรับนักพัฒนา Java ระดับจูเนียร์ ระดับกลาง และระดับสูง คำถามน่าสนใจมาก โดยส่วนตัวแล้วฉันชอบวิเคราะห์มัน เพราะมันช่วยให้ฉันพบช่องว่างในความรู้ทางทฤษฎีของฉัน และในสถานที่ที่ไม่คาดคิดที่สุดบางครั้ง ส่วนก่อนหน้าสามารถพบได้ในบทความนี้ แต่ก่อนที่เราจะเริ่มต้น ฉันต้องการเตือนคุณว่า:

1. ฉันจะข้ามคำถามที่ทับซ้อนกับบทความชุดนี้ เพื่อไม่ให้ข้อมูลซ้ำโดยไม่จำเป็น ฉันขอแนะนำให้อ่านบทความเหล่านี้เนื่องจากครอบคลุมคำถามสัมภาษณ์ Java Core ที่พบบ่อยที่สุด (ยอดนิยม)
2. ฉันสามารถอธิบายคำตอบได้โดยละเอียดมากขึ้น แต่ฉันจะไม่อธิบาย เพราะแต่ละคำตอบอาจลากยาวไปทั้งบทความ และจะไม่มีใครขอรายละเอียดระดับนั้นจากคุณในการสัมภาษณ์งานใดๆ

ฉันจะทิ้งลิงก์ไว้สำหรับการศึกษาเชิงลึกถ้าคุณต้องการ บินกันเถอะ!

11. ตั้งชื่อเมธอดทั้งหมดของคลาส Object

คลาสObjectมี 11 วิธี:

1. Class<?> getClass() — รับคลาสของอ็อบเจ็กต์ปัจจุบัน

2. int hashCode() — รับรหัสแฮชของวัตถุปัจจุบัน

3. บูลีนเท่ากับ (Object obj) - เปรียบเทียบวัตถุปัจจุบันกับวัตถุอื่น

4. Object clone() — สร้างและส่งคืนสำเนาของอ็อบเจ็กต์ปัจจุบัน

5. String toString() - รับการแสดงสตริงของวัตถุ

6. void notify() - ปลุกหนึ่งเธรดที่รออยู่บนมอนิเตอร์ของวัตถุนี้ (ตัวเลือกของเธรดจะเป็นแบบสุ่ม)

7. เป็นโมฆะ notifyAll() - ปลุกเธรดทั้งหมดที่รออยู่บนจอภาพของวัตถุนี้

8. ถือเป็นโมฆะรอ () - ทำให้เธรดปัจจุบันรอบนมอนิเตอร์ปัจจุบัน (หยุดเธรดปัจจุบัน) จนกว่าการแจ้งหรือการแจ้งเตือนทั้งหมดจะปลุกเธรด (ใช้งานได้เฉพาะในบล็อกที่ซิงโครไนซ์เท่านั้น)

9. รอเป็นโมฆะ (หมดเวลานาน) - ทำให้เธรดปัจจุบันรอบนมอนิเตอร์ปัจจุบัน (บนบล็อกซิงโครไนซ์ปัจจุบัน) แต่ด้วยการหมดเวลาสำหรับการออกจากสถานะรอ (หรืออีกครั้งจนกว่าการแจ้งเตือนหรือการแจ้งเตือนทั้งหมดจะปลุกเธรด)

10. ถือเป็นโมฆะรอ (การหมดเวลานาน int nanos) - วิธีการนี้เหมือนกับวิธีก่อนหน้า แต่มีการหมดเวลาที่แม่นยำยิ่งขึ้น

11. ถือเป็นโมฆะสรุป () - วิธีการนี้ถูกเรียก (ในที่สุด) ก่อนที่ตัวรวบรวมขยะจะถูกลบออก มันถูกใช้เพื่อล้างทรัพยากรที่ได้มา

หากต้องการใช้hashCode , เท่ากับ , clone , toStringและสรุปวิธีการอย่างถูกต้อง จะต้องเขียนทับวิธีการเหล่านั้นตามข้อมูลเฉพาะของงานปัจจุบัน

12. อะไรคือความแตกต่างระหว่างการลองกับทรัพยากรและการลองจับในที่สุดเมื่อทำงานกับทรัพยากร?

โดยทั่วไป เมื่อใช้try-catch-finallyบล็อกสุดท้ายจะถูกใช้เพื่อปิดทรัพยากร Java 7 แนะนำคำสั่งtry-with-resources ใหม่ มันคล้ายคลึงกับการลองจับขั้นสุดท้ายเพื่อเพิ่มทรัพยากร แต่มีขนาดกะทัดรัดและอ่านง่ายกว่า ลองนึกถึงสิ่งที่try-catch-finallyมีลักษณะดังนี้:

String text = "some text......";
BufferedWriter bufferedWriter = null;
try {
   bufferedWriter = new BufferedWriter(new FileWriter("someFileName"));
   bufferedWriter.write(text);
} catch (IOException e) {
   e.printStackTrace();
} finally {
   try {
       bufferedWriter.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
}

ตอนนี้เรามาเขียนโค้ดนี้ใหม่ แต่ใช้try-with-resources :

String text = "some text......";
try(BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("someFileName"))) {
   bufferedWriter.write(text);
} catch (IOException e) {
   e.printStackTrace();
}

ตอนนี้มันง่ายกว่านี้คุณไม่คิดเหรอ? นอกจากโค้ดที่ง่ายกว่าแล้ว ยังมีประเด็นอื่นๆ อีกสองสามข้อที่ควรทราบ:

1. ในtry-with-resourcesทรัพยากรที่ประกาศในวงเล็บ (ทรัพยากรที่จะถูกปิด) จะต้องใช้ อินเทอร์เฟซ AutoCloseableและวิธีการ close() เพียงอย่างเดียว

   วิธีการปิดจะดำเนินการโดยปริยายในที่สุด blockมิฉะนั้นโปรแกรมจะทราบได้อย่างไรว่าจะปิดทรัพยากรอย่างไร

   แต่คุณอาจจะไม่ค่อยเขียนการใช้งานทรัพยากรและวิธีการปิดของคุณเอง

2. บล็อกจะดำเนินการตามลำดับนี้:

   1. การลองบล็อก
   2. ในที่สุดนัยก็ปิดกั้น
   3. catch block ซึ่งจับข้อยกเว้นที่เกิดขึ้นในขั้นตอนก่อนหน้านี้
   4. ในที่สุดความชัดเจนก็ปิดกั้น

   ตามกฎแล้ว ข้อยกเว้นที่อยู่ต่ำกว่าในรายการจะขัดจังหวะข้อยกเว้นที่อยู่สูงกว่า

ลองนึกภาพว่าคุณกำลังใช้try-catch-finallyและคุณได้รับข้อยกเว้นในtry block จากนั้นcatch block ที่ระบุจะเริ่มดำเนินการทันที ซึ่งเราได้เขียนข้อยกเว้นอื่นไว้ (เช่น พร้อมข้อความที่อธิบายข้อผิดพลาดโดยละเอียดมากขึ้น) และคุณต้องการให้เมธอดส่งข้อยกเว้นนี้ขึ้นด้านบน จากนั้น บล็อก สุดท้ายก็จะถูกดำเนินการและมีข้อยกเว้นเกิดขึ้นด้วย แต่ครั้งนี้แตกต่างออกไป ในที่สุดวิธีนี้จะทิ้งข้อยกเว้นใดในสองข้อนี้ ข้อยกเว้นที่ถูกโยนทิ้งโดย บล็อก ในที่สุด ! แต่ตอนนี้เรามาถึงอีกจุดหนึ่งเกี่ยวกับtry-with- resources ลองพิจารณาว่าการลองใช้ทรัพยากรทำงานอย่างไรในสถานการณ์เดียวกัน เราได้รับข้อยกเว้นในtry block เมื่อพยายามปิดทรัพยากรด้วย เมธอด close()กล่าวคือในท้ายที่สุดก็บล็อก โดยปริยาย catch block catchมีข้อยกเว้นใดต่อไปนี้บ้าง อันที่ลองบล็อกโยน ! ข้อยกเว้นจากบล็อกโดยนัยในท้ายที่สุด (จาก วิธี loss() ) จะถูกละเว้น การเพิกเฉยต่อข้อยกเว้นนี้เรียกอีกอย่างว่าการระงับข้อยกเว้น

13. การดำเนินการระดับบิตคืออะไร?

การดำเนินการระดับบิตคือการดำเนินการตามลำดับของบิต รวมถึงการดำเนินการเชิงตรรกะและการเปลี่ยนแปลงระดับบิต ตัวดำเนินการเชิงตรรกะ:

• ระดับบิตและ - เปรียบเทียบค่าบิต บิตใดๆ ที่ตั้งค่าเป็น 0 (เท็จ) จะตั้งค่าบิตที่สอดคล้องกันในผลลัพธ์เป็น 0 กล่าวคือ หากบิตเป็น 1 (จริง) ในทั้งสองค่าที่เปรียบเทียบ บิตผลลัพธ์จะเป็น 1 ด้วย

  แสดงว่าANDหรือ&

  ตัวอย่าง: 10111101 & 01100111 = 00100101

• bitwise OR — การดำเนินการนี้ตรงกันข้ามกับการดำเนินการก่อนหน้า บิตใดๆ ที่ตั้งค่าเป็น 1 จะตั้งค่าบิตที่สอดคล้องกันในผลลัพธ์เป็น 1 ดังนั้น หากบิตเป็น 0 ในค่าที่เปรียบเทียบทั้งสองค่า บิตผลลัพธ์จะเป็น 0 เช่นกัน

  แสดงเป็นORหรือ|

  ตัวอย่าง: 10100101 | 01100011 = 11100111

• ระดับบิตNOT — โอเปอเรเตอร์นี้ใช้กับค่าเดียว มันพลิก (กลับ) บิต นั่นคือบิตที่เป็น 1 จะกลายเป็น 0 และพวกที่เป็น 0 จะกลายเป็น 1

  แสดงเป็นNOTหรือ~

  ตัวอย่าง: ~10100101 = 01011010

• เอกสิทธิ์ระดับบิตหรือ - เปรียบเทียบค่าบิต ถ้าทั้งสองบิตเป็น 1 บิตผลลัพธ์จะเป็น 0 หากบิตทั้งสองเป็น 0 บิตผลลัพธ์จะเป็น 0 กล่าวอีกนัยหนึ่ง เพื่อให้บิตผลลัพธ์เป็น 1 เพียงบิตเดียวต้องเป็น 1 และ อีกบิตต้องเป็น 0

  แสดงว่าXORหรือ^

  ตัวอย่าง: 10100101 ^ 01100011 = 11000110

การเลื่อนระดับบิต ( >>และ<< ) เลื่อนบิตของตัวถูกดำเนินการไปในทิศทางที่ระบุตามจำนวนตำแหน่งที่ระบุ ตำแหน่งที่ว่างจะเต็มไปด้วยศูนย์ ตัวอย่างเช่น:

1. 01100011 >> 4 = 00000110
2. 01100011 << 3 = 00011000

ข้อยกเว้นคือเมื่อคุณเลื่อนตัวเลขลบไปทางขวา ดังที่คุณคงจำได้ บิตแรกของหมายเลขที่เซ็นชื่อบ่งบอกถึงเครื่องหมายนั้น ถ้าบิตนี้เป็น 1 แสดงว่าตัวเลขนั้นเป็นลบ หากคุณเลื่อนจำนวนลบ ตำแหน่งที่ว่างจะไม่เต็มไปด้วยศูนย์ แต่จะเต็มไปด้วยตำแหน่ง เนื่องจากบิตเครื่องหมายจะต้องถูกรักษาไว้ ตัวอย่างเช่น: 10100010 >> 2 = 11101000 ที่กล่าวว่า Java มีตัวดำเนินการกะขวาเพิ่มเติมที่ไม่ได้ลงนาม (>>>) ตัวดำเนินการนี้คล้ายคลึงกับ >> แต่เมื่อถูกเลื่อนตำแหน่งที่ว่างจะถูกเติมด้วย 0 ไม่ว่าตัวถูกดำเนินการจะเป็นจำนวนลบหรือจำนวนบวกก็ตาม ตัวอย่างเช่น: 10100010 >>> 2 = 00101000 อ่านเพิ่มเติมเกี่ยวกับการดำเนินการระดับบิตที่ นี่ คุณสามารถใช้ เมธอด hash()ใน HashMaps เป็นตัวอย่างของการเปลี่ยนแปลงระดับบิตใน Java วิธีการนี้ใช้เพื่อกำหนดแฮชโค้ดภายในพิเศษของคีย์: วิธีนี้ช่วยให้คุณกระจายข้อมูลใน HashMap เท่าๆ กัน เพื่อลดจำนวนการชนกัน

14. มีออบเจ็กต์มาตรฐานที่ไม่เปลี่ยนรูปแบบใดบ้างใน Java?

วัตถุจะไม่เปลี่ยนรูปหากไม่อนุญาตให้เปลี่ยนค่าดั้งเดิม อาจมีเมธอดที่ส่งคืนอ็อบเจ็กต์ใหม่ที่เป็นประเภทเดียวกันด้วยค่าที่แตกต่างกัน ออบเจ็กต์มาตรฐานที่ไม่เปลี่ยนรูปบางรายการได้แก่:

• ไม่ต้องสงสัยเลยว่าประเภทที่ไม่เปลี่ยนรูปที่มีชื่อเสียงที่สุดของ Java คือ String;
• อินสแตนซ์ของคลาส wrapper ที่รวมประเภทมาตรฐาน: บูลีน, อักขระ, ไบต์, สั้น, จำนวนเต็ม, ยาว, สองเท่า, ลอย;
• ออบเจ็กต์ BigInteger และ BigDecimal ซึ่งโดยทั่วไปใช้สำหรับตัวเลข BIG โดยเฉพาะ
• ออบเจ็กต์ StackTraceElement ที่ประกอบเป็นการติดตามสแต็ก (เช่น การติดตามสแต็กของข้อยกเว้น)
• อ็อบเจ็กต์ของคลาส File — มันสามารถแก้ไขไฟล์ได้ แต่ในขณะเดียวกันอ็อบเจ็กต์เองก็ยังคงไม่เปลี่ยนแปลง
• UUID ซึ่งมักใช้เพื่อระบุองค์ประกอบโดยไม่ซ้ำกัน
• อ็อบเจ็กต์ทั้งหมดของคลาสในแพ็คเกจ java.time
• ออบเจ็กต์สถานที่ ซึ่งใช้เพื่อระบุภูมิภาคทางภูมิศาสตร์ การเมือง หรือวัฒนธรรม

15. ข้อดีของวัตถุที่ไม่เปลี่ยนรูปเหนือวัตถุธรรมดาคืออะไร?

1. อ็อบเจ็กต์ที่ไม่เปลี่ยนรูปมีความปลอดภัยในการใช้งานในสภาพแวดล้อมแบบมัลติเธรด พวกเขาสร้างมันขึ้นมาเพื่อให้คุณไม่ต้องกังวลกับข้อมูลสูญหายเนื่องจากสภาพการแข่งขัน สิ่งนี้แตกต่างจากเมื่อคุณทำงานกับวัตถุธรรมดา ในกรณีนี้คุณต้องคิดและสร้างกลไกที่ดีเมื่อใช้วัตถุในสภาพแวดล้อมแบบขนาน

2. วัตถุที่ไม่เปลี่ยนรูปนั้นดีเหมือนกุญแจในแผนที่ หากคุณใช้ออบเจ็กต์ที่ไม่แน่นอนเป็นคีย์ HashMap แล้วสถานะของออบเจ็กต์เปลี่ยนไป โครงสร้างข้อมูลอาจสับสนได้: ออบเจ็กต์จะยังคงอยู่ แต่ถ้าคุณใช้ containsKey() คุณอาจไม่พบมัน

3. วัตถุที่ไม่เปลี่ยนรูปเหมาะอย่างยิ่งสำหรับการจัดเก็บข้อมูลที่ไม่เปลี่ยนรูป (คงที่) ซึ่งไม่ควรเปลี่ยนแปลงในขณะที่โปรแกรมกำลังทำงาน

4. ข้อดีอีกประการหนึ่งคือความล้มเหลวของอะตอมมิกซิตี หากวัตถุที่ไม่เปลี่ยนรูปส่งข้อยกเว้น มันจะไม่ถูกปล่อยให้อยู่ในสถานะที่ไม่ต้องการ (ใช้งานไม่ได้)

5. ชั้นเรียนเหล่านี้ง่ายต่อการทดสอบ

6. คุณไม่จำเป็นต้องมีกลไกเพิ่มเติมใดๆ เช่น ตัวสร้างการคัดลอกหรือการใช้งานการโคลนวัตถุ

คำถามเกี่ยวกับ OOP

16. ข้อดีของ OOP โดยทั่วไปและเมื่อเปรียบเทียบกับการเขียนโปรแกรมตามขั้นตอนคืออะไร?

เอาล่ะ ข้อดีของ OOP:

1. แอปพลิเคชันที่ซับซ้อนจะเขียนโดยใช้ OOP ได้ง่ายกว่าการเขียนโปรแกรมตามขั้นตอน เนื่องจากทุกอย่างถูกแบ่งออกเป็นโมดูลขนาดเล็ก — วัตถุที่มีปฏิสัมพันธ์ระหว่างกัน — และด้วยเหตุนี้ การเขียนโปรแกรมจึงลดลงเหลือเพียงความสัมพันธ์ระหว่างวัตถุ

2. แอปพลิเคชันที่เขียนด้วย OOP จะปรับเปลี่ยนได้ง่ายกว่ามาก (เมื่อปฏิบัติตามหลักการออกแบบอย่างเหมาะสม)

3. เนื่องจากทั้งข้อมูลและการดำเนินการข้อมูลเป็นเอนทิตีเดียว จึงไม่เลอะไปทั่วแอปพลิเคชัน (ซึ่งมักเป็นกรณีในการเขียนโปรแกรมตามขั้นตอน)

4. หลักการของการห่อหุ้มจะปกป้องข้อมูลที่สำคัญที่สุดจากผู้ใช้

5. รหัสเดียวกันสามารถนำมาใช้ซ้ำกับข้อมูลที่แตกต่างกันได้ เนื่องจากคลาสช่วยให้คุณสร้างออบเจ็กต์จำนวนมาก โดยแต่ละออบเจ็กต์มีค่าของตัวเอง

6. การสืบทอดและความหลากหลายยังช่วยให้คุณใช้ซ้ำและขยายโค้ดที่มีอยู่ได้ (แทนที่จะทำซ้ำฟังก์ชันการทำงานที่คล้ายกัน)

7. การขยายแอปพลิเคชันนั้นง่ายกว่าการใช้แนวทางตามขั้นตอน

8. แนวทาง OOP ช่วยให้สามารถสรุปรายละเอียดการใช้งานได้

17. บอกเราว่า OOP มีข้อเสียอะไรบ้าง

น่าเสียดายที่ยังมีอยู่ด้วย:

1. OOP ต้องใช้ความรู้ทางทฤษฎีมากมายซึ่งต้องเชี่ยวชาญก่อนจึงจะสามารถเขียนอะไรก็ได้

2. แนวคิด OOP ไม่ใช่เรื่องง่ายที่จะเข้าใจและนำไปใช้ในทางปฏิบัติ (คุณต้องเป็นนักปรัชญาตัวน้อยในหัวใจ)

3. OOP ลดประสิทธิภาพของโปรแกรมเล็กน้อยเนื่องจากความซับซ้อนของระบบที่เพิ่มขึ้น

4. วิธี OOP ต้องใช้หน่วยความจำมากขึ้นเนื่องจากทุกอย่างประกอบด้วยคลาส อินเทอร์เฟซ วิธีการ ซึ่งใช้หน่วยความจำมากกว่าตัวแปรทั่วไปมาก

5. เวลาที่จำเป็นสำหรับการวิเคราะห์เบื้องต้นนั้นมากกว่าเวลาสำหรับแนวทางขั้นตอน

18. ความแตกต่างแบบคงที่กับความหลากหลายแบบไดนามิกคืออะไร?

Polymorphism ช่วยให้วัตถุที่มีคลาสหรืออินเทอร์เฟซเดียวกันทำงานแตกต่างกัน ความหลากหลายมีสองประเภท ซึ่งเรียกอีกอย่างว่าการเชื่อมโยงตั้งแต่เนิ่นๆ และภายหลัง ความหลากหลายแบบคงที่หรือการจับตั้งแต่เนิ่นๆ:

• เกิดขึ้นในเวลาคอมไพล์ (ช่วงต้นของวงจรชีวิตของโปรแกรม);
• ตัดสินใจว่าจะดำเนินการอย่างไรในเวลารวบรวม
• วิธีการโอเวอร์โหลดเป็นตัวอย่างของความหลากหลายแบบคงที่
• การผูกล่วงหน้ารวมถึงวิธีการส่วนตัว คงที่ และสุดท้าย
• มรดกไม่เกี่ยวข้องกับการผูกมัดก่อนกำหนด
• ความหลากหลายแบบคงที่ไม่เกี่ยวข้องกับวัตถุเฉพาะ แต่เป็นข้อมูลเกี่ยวกับประเภทคลาสที่ปรากฏทางด้านซ้ายของชื่อตัวแปร

ความหลากหลายแบบไดนามิกหรือการผูกล่าช้า:

• เกิดขึ้นเมื่อรันไทม์ (ในขณะที่โปรแกรมกำลังทำงาน)
• ความหลากหลายแบบไดนามิกจะตัดสินว่าวิธีการใดที่จะมีการใช้งานเฉพาะที่รันไทม์
• การเอาชนะวิธีการเป็นตัวอย่างหนึ่งของความหลากหลายแบบไดนามิก
• การผูกล่าช้าหมายถึงการกำหนดวัตถุเฉพาะ การอ้างอิงประเภทหรือซูเปอร์คลาส
• การสืบทอดมีความเกี่ยวข้องกับความหลากหลายแบบไดนามิก

19. ให้คำจำกัดความของหลักการของนามธรรมใน OOP

ใน OOP สิ่งที่เป็นนามธรรมคือวิธีการแยกชุดคุณลักษณะที่มีความหมายของวัตถุ โดยไม่รวมรายละเอียดที่ไม่มีนัยสำคัญ นั่นคือเมื่อออกแบบโปรแกรมด้วยแนวทาง OOP คุณจะมุ่งเน้นไปที่โมเดลทั่วไปโดยไม่ต้องลงรายละเอียดการใช้งาน ใน Java สิ่งที่เป็นนามธรรมจะเกิดขึ้นผ่านอินเทอร์เฟ ซ ตัวอย่างเช่น คุณมีรถยนต์และนั่นจะเป็นอินเทอร์เฟซ และการโต้ตอบต่างๆ กับมัน เช่น การสตาร์ทเครื่องยนต์ การเปลี่ยนเกียร์ ถือเป็นฟังก์ชันต่างๆ ที่เราใช้โดยไม่ต้องเจาะลึกรายละเอียดการใช้งาน แท้จริงแล้ว เมื่อคุณขับรถ คุณไม่ได้คิดถึงวิธีที่กระปุกเกียร์บรรลุวัตถุประสงค์ของมัน กุญแจสตาร์ทเครื่องยนต์อย่างไร หรือพวงมาลัยหมุนล้ออย่างไร และหากคุณเปลี่ยนการใช้งานฟังก์ชันบางอย่าง (เช่น เครื่องยนต์) คุณอาจไม่สังเกตเห็นด้วยซ้ำ มันไม่สำคัญสำหรับคุณ: คุณไม่ได้เจาะลึกรายละเอียดการใช้งาน สิ่งที่สำคัญสำหรับคุณคือการดำเนินการนั้นได้ดำเนินการไปแล้ว โดยพื้นฐานแล้วรายละเอียดการดำเนินการที่เป็นนามธรรมนี้ออกไป ณ จุดนี้ เราจะหยุดในวันนี้: ดำเนินต่อไป!