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

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

20. องค์ประกอบภาษาใดบ้างที่รับผิดชอบในการห่อหุ้ม?

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

21. องค์ประกอบภาษาใดบ้างที่รับผิดชอบในการสืบทอด?

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

public class Lion extends Cat

และนั่นหมายความว่า คลาส Lionจะสืบทอดวิธีการและตัวแปรทั้งหมดของ คลาส Catยกเว้นแบบคงที่ นอกจากนี้ องค์ประกอบภาษาที่รับผิดชอบในการสืบทอดยังรวมถึงsuper นี่คือการอ้างอิงที่คล้ายกับthisแต่ในขณะที่สิ่งนี้อ้างถึงอ็อบเจ็กต์ที่ถูกเรียก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 คีย์เวิร์ด ImplementและExtendedมีความรับผิดชอบต่อความหลากหลาย นำไปใช้ - เมื่อเราสร้างอินเทอร์เฟซของเรา เราจะใช้หนึ่งในรูปแบบที่เป็นไปได้ในบางคลาส แต่ไม่ใช่รูปแบบเดียวใช่ไหม โปรดจำไว้ว่าการดำเนินการนำ ไปใช้มีลักษณะดังนี้ :

public class Cat implements Animal

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

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

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

24. คลาส, วัตถุ, อินเทอร์เฟซคืออะไร?

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

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

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

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

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

27. อธิบายการสืบทอดในภาษา Java การใช้ super keyword มีประโยชน์อย่างไร?

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

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

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

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

doSomething(int, double, double)

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

void doSomething(int firstArg, int secondArg) throws Exception

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