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

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

20. องค์ประกอบใดของภาษาที่ทำให้เกิดการห่อหุ้มได้?

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

21. องค์ประกอบใดของภาษาที่ทำให้เกิดการสืบทอด?

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

public class Lion extends Cat

และนั่นหมายความว่า คลาส Lionจะสืบทอดวิธีการและตัวแปรทั้งหมดของ คลาส Catยกเว้นตัวแปรแบบคงที่ องค์ประกอบอีกประการหนึ่งของภาษาที่รับผิดชอบในการสืบทอดคือsuper เป็นการอ้างอิงที่คล้ายกับสิ่งนี้ คำ สำคัญ นี้อ้างอิงถึงออบเจ็กต์ที่มีการอ้างอิง คีย์เวิร์ดsuperอ้างอิงถึงพาเรนต์ของออบเจ็กต์ปัจจุบัน โดยทั่วไปแล้วจะใช้super :

1. เพื่อเรียกตัวสร้างของซูเปอร์คลาส ตัวอย่างเช่น คลาส Catมี ตัวแปร ชื่อ ภายใน ที่ต้องเตรียมใช้งานในตัวสร้าง ใน ตัวสร้างคลาส Lionซึ่งจะมีลักษณะดังนี้:

   public Lion(final String name) {
      super(name);
   }

2. เพื่ออ้างถึงสาขาและวิธีการของผู้ปกครอง ตัวอย่างเช่น ใน คลาส Catเรามี ฟิลด์ อายุ เริ่มต้น :

   public class Cat {
      int age = 10;

แต่เรามีฟิลด์เริ่มต้นเหมือนกันในLion :

public class Lion extends Cat {
   int age = 15;

และหากใน วัตถุ Lionเราต้องการอ้างถึง ตัวแปร อายุของวัตถุแม่ เราก็ต้องทำมันผ่านsuper :

super.name

22. องค์ประกอบใดของภาษาที่รับผิดชอบต่อความหลากหลาย?

Polymorphism คือความสามารถของออบเจ็กต์ที่มีลายเซ็นเดียวในการมีหลายรูปแบบ (การใช้งานหลายอย่าง) เราสามารถระบุได้อย่างมั่นใจว่าการใช้และขยายคำหลักของ Java มีความรับผิดชอบต่อความหลากหลาย เมื่อเรามีอินเทอร์เฟซ Implementsจะทำให้เราสามารถจัดเตรียมการนำไปใช้งานที่เป็นไปได้อย่างหนึ่ง แต่นั่นไม่จำเป็นต้องเป็นเพียงการนำไปใช้งานเพียงอย่างเดียว ใช่ไหม? เรามาทบทวนดูว่าการใช้Implements เป็นอย่างไร :

public class Cat implements Animal

จากนั้นใน คลาส Catเราต้องใช้วิธีนามธรรมทั้งหมดในส่วนต่อประสานAnimal การสืบทอดเช่นกัน: ในคลาสย่อย เราสามารถแทนที่การใช้งานที่มีอยู่ของเมธอดได้ ซึ่งหมายความว่าด้วยคลาสย่อยหลายคลาส เราสามารถมีเมธอดเดียวกันที่แตกต่างกันได้หลายวิธี หรือซูเปอร์คลาสอาจเป็นนามธรรมและมีวิธีการบางอย่างที่ต้องนำไปใช้ในลักษณะพิเศษในแต่ละคลาสย่อย กล่าวอีกนัยหนึ่ง วิธีการนี้จะมีการใช้งานที่แตกต่างกันมากมาย คำ อธิบายประกอบ @Overrideยังสามารถช่วยเราได้ในเรื่องนี้ มันถูกวางไว้เหนือวิธีการที่นำไปใช้และบ่งชี้ว่าเราต้องการนำไปใช้หรือแทนที่ (หากมีการใช้งานอยู่แล้วในซูเปอร์คลาส) วิธีการเฉพาะของซูเปอร์คลาสหรืออินเทอร์เฟซ เป็นทางเลือกและช่วยตรวจจับข้อผิดพลาดได้ง่ายขึ้น คุณใช้คำอธิบายประกอบนี้เพื่อบอกคอมไพเลอร์ว่าคุณต้องการแทนที่/ใช้เมธอด superclass/interface คอมไพเลอร์จะตรวจสอบให้แน่ใจว่าคุณไม่ทำผิดพลาดในลายเซ็นวิธีการ

23. โซลิดคืออะไร? ให้ตัวอย่าง

SOLIDเป็นตัวย่อสำหรับหลักการออกแบบ OOP พื้นฐานห้าประการของ Robert Martin S (หลักการความรับผิดชอบเดียว) : ระบุว่าชั้นเรียนควรมีวัตถุประสงค์/ความรับผิดชอบเดียวเท่านั้น กล่าวอีกนัยหนึ่ง คุณไม่ควรสร้างคลาสที่ทำทุกอย่าง หากคุณทำเช่นนั้น คุณสามารถสร้างรูปแบบการต่อต้าน "God Object" ได้ หากคุณมี ออบเจ็กต์ Catก็ควรมีวิธีการโต้ตอบกับฟังก์ชันการทำงานภายในเท่านั้น แต่ไม่ควรมีเหตุผลทางธุรกิจใดๆ ที่ไม่เกี่ยวข้องกับอินสแตนซ์นั้น ตัวอย่างเช่นกลไกบางอย่างในการจัดเก็บวัตถุประเภทนี้ ฟังก์ชั่นนี้ (ภายนอกเอนทิตีของCat ) ควรถูกย้ายไปยังคลาสหรือบริการอื่น ซึ่งมีหน้าที่จัดเตรียมตรรกะทางธุรกิจสำหรับออบเจ็กต์ที่เกี่ยวข้อง O (หลักการเปิด-ปิด) : หลักการนี้อธิบายไว้ดังนี้ เอนทิตีซอฟต์แวร์ (คลาส โมดูล ฟังก์ชัน ฯลฯ) ควรเปิดเพื่อขยาย แต่ปิดเพื่อแก้ไข ตัวอย่างเช่น สมมติว่าเราต้องการฟังก์ชันการทำงานที่คล้ายกันแต่แตกต่างเล็กน้อยจากฟังก์ชันการทำงานของคลาสCat ที่มีอยู่ของเรา แทนที่จะเปลี่ยนฟังก์ชันการทำงานของ คลาส Catและทำลายโค้ดทุกที่ที่มีการใช้งานอยู่แล้ว เราสามารถใช้การสืบทอดหรือการจัดองค์ประกอบ ได้ ดังนั้นเราจึงบรรลุเป้าหมายในการปรับเปลี่ยนฟังก์ชันการทำงานของ คลาส Catและเราทำสิ่งนั้นโดยไม่เปลี่ยนคลาสเองและไม่ทำลายสิ่งใดเลย L (หลักการทดแทนลิสคอฟ) : นี่คือหลักการทดแทนของบาร์บารา ลิสคอฟ หลักการบอกว่าฟังก์ชันที่ใช้ประเภทฐานควรจะสามารถใช้ประเภทย่อยของประเภทฐานนั้นได้โดยไม่รู้ว่าเกิดอะไรขึ้น ตัวอย่างเช่น คลาส Cat ของเรา ควรจะถูกแทนที่โดยคลาสที่สืบทอดเช่นLionโดยไม่เปลี่ยนแปลงพฤติกรรมโดยพื้นฐาน ตรรกะทั่วไป (พฤติกรรม) ยังคงเหมือนเดิม แต่รายละเอียดการใช้งานของฟังก์ชันเฉพาะเปลี่ยนไป I (หลักการแยกส่วนต่อประสาน) : หลักการนี้ระบุว่าจะดีกว่าที่จะมีอินเทอร์เฟซพิเศษจำนวนมาก (เน้นแคบ) มากกว่าอินเทอร์เฟซสากลเดียว ตัวอย่างเช่น สมมติว่านักพัฒนาใช้อินเทอร์เฟซบางอย่าง พวกเขาต้องการเพียงวิธีใดวิธีหนึ่งเท่านั้น แต่อินเทอร์เฟซมีอีกเก้าวิธีที่ไม่เกี่ยวข้องกับตรรกะของวิธีที่ต้องการ ในกรณีนี้นักพัฒนาจะต้องใช้วิธีการเชื่อมต่อสิบวิธี โดยเก้าวิธีนั้นไม่จำเป็นสำหรับพวกเขา! แต่จะเป็นการดีกว่าถ้าสร้างอินเทอร์เฟซที่แตกต่างกัน 10 แบบซึ่งคุณสามารถนำไปใช้ได้ตามต้องการ ถ้าไม่ใช่สิบก็มีหลายวิธี แต่ละวิธีมีความสัมพันธ์อย่างใกล้ชิดกับจุดประสงค์เดียวของอินเทอร์เฟซ D (หลักการผกผันการพึ่งพา): หลักการบอกว่าโมดูลระดับสูงกว่าไม่ควรขึ้นอยู่กับโมดูลระดับล่าง หลักการนี้ยังระบุด้วยว่า "นามธรรมไม่ควรขึ้นอยู่กับรายละเอียด รายละเอียดควรขึ้นอยู่กับนามธรรม" เราต้องสร้างตรรกะของเราโดยอ้างถึงอินเทอร์เฟซและส่งผ่านอ็อบเจ็กต์ที่เป็นรูปธรรมของคลาสที่ใช้อินเทอร์เฟซที่ต้องการ ตัวอย่างเช่น สมมติว่าเรามี อินเท อ ร์เฟ ซ Catและการใช้งานบางอย่าง เช่นLionและHouseCat เราสร้างตรรกะของเราโดยเฉพาะเพื่อโต้ตอบกับอินเทอร์เฟซCat จากนั้นเราจะแทนที่อินเทอร์เฟซด้วยการใช้งานเฉพาะ ( LionหรือHouseCat ) แต่ไม่ใช่วิธีอื่น

24. คลาส อ็อบเจ็กต์ และอินเทอร์เฟซคืออะไร?

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

25. คลาส POJO คืออะไร? ยกตัวอย่างชั้นเรียนดังกล่าว

POJO (Plain Old Java Object)เป็นคลาสอ็อบเจ็กต์ธรรมดาที่ไม่ได้รับการสืบทอดจากคลาสเฉพาะใดๆ และไม่ได้ใช้อินเทอร์เฟซบริการใดๆ ที่เกินกว่าที่จำเป็นสำหรับโมเดลธุรกิจ กล่าวอีกนัยหนึ่ง คลาส POJOเป็นเพียงคลาสที่ไม่มีข้อกำหนดพิเศษ ข้อกำหนดเพียงอย่างเดียวคือการไม่มีระฆังและนกหวีดต่าง ๆ ที่เชื่อมโยงกับกรอบงานเฉพาะ ตามกฎแล้ว คลาสเหล่านี้จะไม่สืบทอดคลาสอื่น (ยกเว้น คลาส POJOในแพ็คเกจเดียวกัน) ห้ามใช้อินเทอร์เฟซ (บางครั้งมีข้อยกเว้นสำหรับอินเทอร์เฟซมาร์กเกอร์จากไลบรารีมาตรฐาน เช่นSerializableหรือCloneable ) ห้ามใช้คำอธิบายประกอบ และไม่ขึ้นอยู่กับไลบรารีของบุคคลที่สาม โปรดทราบว่าPOJOสามารถมีวิธีการที่มีตรรกะทางธุรกิจและตัวสร้างชนิดใดก็ได้ หากเราอนุญาตให้ใช้คำอธิบายประกอบที่ไม่เปลี่ยนความหมายของคลาส (เช่น คำอธิบายประกอบที่ไม่มีอยู่ไม่ได้เปลี่ยนวัตถุประสงค์หรือตรรกะของออบเจ็กต์) ดังนั้น POJO ยังสามารถรวมเอนทิตี JPA และออบเจ็กต์ DTO ดีซีเรียลไลซ์จาก XML หรือ JSON ซึ่งมีกฎอยู่ ระบุไว้ในคำอธิบายประกอบ อีกสิ่งหนึ่งที่ควรคำนึงถึงเกี่ยวกับ คลาส POJOก็คือ เป็นการดีที่จะแทนที่เมธอดเท่ากับและhashCodeเพราะสิ่งนี้สามารถช่วยให้พวกเขาบรรลุบทบาทได้ดีขึ้น ตัวอย่างของ คลาส POJO :

public class User {
   private Long id;
   private String firstName;
   private String lastName;
   private Long age;

   public User(final Long id, final String firstName, final String lastName, final long age) {
       this.id = id;
       this.firstName = firstName;
       this.lastName = lastName;
       this.age = age;
   }

   public Long getId() {
       return this.id;
   }

   public String getFirstName() {
       return this.firstName;
   }

   public String getLastName() {
       return this.lastName;
   }

   public Long getAge() {
       return this.age;
   }

   @Override
   public boolean equals(final Object o) {
       if (this == o) return true;
       if (o == null || this.getClass() != o.getClass()) return false;
       final User user = (User) o;
       return Objects.equals(this.id, user.id) &&
               Objects.equals(this.firstName, user.firstName) &&
               Objects.equals(this.lastName, user.lastName) &&
               Objects.equals(this.age, user.age);
   }

   @Override
   public int hashCode() {
       return Objects.hash(this.id, this.firstName, this.lastName, this.age);
   }
}

26. คลาสสามารถมีองค์ประกอบอะไรบ้าง?

ชั้นเรียนสามารถมีองค์ประกอบดังต่อไปนี้:

• ฟิลด์อินสแตนซ์;
• สนามคงที่
• บล็อกการเริ่มต้น
• บล็อกการเริ่มต้นแบบคงที่
• ตัวสร้าง (ตัวสร้างว่างจะถูกประกาศตามค่าเริ่มต้นเสมอ);
• วิธีการ;
• วิธีการคงที่
• คำอธิบายประกอบต่างๆ (ซึ่งสามารถนำไปใช้กับคลาสเองหรือส่วนที่เป็นส่วนประกอบ)
• ยาสามัญ ;
• การสืบทอดคลาสอื่น ( extend ) หรือการใช้งานอินเทอร์เฟซ ( Implys )

27. บอกเราเกี่ยวกับการสืบทอดใน Java ซูเปอร์คีย์เวิร์ดมีความเฉพาะเจาะจงอย่างไร?

ข้างต้น ก่อนหน้านี้ฉันเคยพูดถึงการสืบทอดและซูเปอร์คีย์เวิร์ดใน Java ฉันจะพูดถึงประเด็นสำคัญอีกสองสามข้อ:

1. เราสามารถสืบทอดได้เพียงคลาสเดียวเท่านั้น: Java ไม่มีการสืบทอดหลายรายการใน Java ด้วยการมาถึงของวิธีการเริ่มต้นใน Java 8 คำสั่งนี้จะกลายเป็นข้อโต้แย้งอย่างมาก
2. วิธีการและฟิลด์ส่วนตัวก็สืบทอดมาเช่นกัน พวกเขาไม่สามารถเข้าถึงได้จากคลาสย่อย (แต่หากเรามีฟิลด์ส่วนตัวและมี getters และ setters สาธารณะหรือที่ได้รับการป้องกันเราก็สามารถใช้มันเพื่อเข้าถึงฟิลด์ได้)
3. คลาส สุดท้ายไม่สามารถสืบทอดได้
4. วิธีการ สุดท้ายไม่สามารถแทนที่ได้ (แต่สามารถสืบทอดและโอเวอร์โหลดได้)
5. วิธีการและตัวแปร แบบสแตติกจะไม่สืบทอด (เนื่องจากแนบไปกับคลาส ไม่ใช่อ็อบเจ็กต์)
6. เมื่อสืบทอดคลาสนามธรรม จะต้องใช้วิธีการเชิงนามธรรม หรือคลาสลูกจะต้องถูกประกาศให้เป็นนามธรรมด้วย
7. หากมี Constructor ที่ไม่ใช่ค่าเริ่มต้นในพาเรนต์ จะต้องถูกแทนที่ในคลาสย่อย (แต่@Overrideไม่ได้เขียนไว้ด้านบน)
8. คุณสามารถขยายตัวแก้ไขการเข้าถึงไปยังวิธีการ แทนที่ในคลาสลูก: private -> default -> protected -> public
วิธีการที่ถูกแทนที่ในคลาสลูกอาจทำให้เกิดข้อยกเว้นที่แคบลงได้ เช่น: Exception -> IOException -> FileNotFoundException

28. ลายเซ็นวิธีการคืออะไร? ยกตัวอย่างลายเซ็นที่ถูกต้องและไม่ถูกต้อง

ลายเซ็นวิธีการ คือชื่อของวิธีการบวกกับประเภทของพารามิเตอร์อินพุต (ลำดับของพารามิเตอร์มีความสำคัญ) ลายเซ็นวิธีการไม่รวมค่าที่ส่งคืนหรือข้อยกเว้นที่วิธีการพ่น ตัวอย่างลายเซ็นที่ถูกต้อง:

doSomething(int, double, double)

ตัวอย่างลายเซ็นที่ไม่ถูกต้อง:

void doSomething(int firstArg, int secondArg) throws Exception

ลายเซ็นเมธอด รวมกับประเภทการส่งคืนและรายการข้อยกเว้นที่ถูกโยนทิ้ง เรียกว่าสัญญาเมธอด นั่นคือทั้งหมดสำหรับวันนี้! แล้วพบกันใหม่!