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

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

39. ตัวดัดแปลงการเข้าถึงใน Java คืออะไร? ตั้งชื่อพวกเขา พวกเขาใช้ทำอะไร?

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

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

40. ตั้งชื่อคุณสมบัติหลักของวิธีแบบคงที่และไม่คงที่

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

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

เราไม่จำเป็นต้องมีอินสแตนซ์ของ คลาส CatServiceเพื่อเรียกมัน:

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

ในทางตรงกันข้าม วิธีการธรรมดาจะถูกผูกไว้กับวัตถุ หากต้องการโทรหาคุณต้องมีอินสแตนซ์ (อ็อบเจ็กต์) ที่จะเรียกใช้เมธอด ตัวอย่างเช่น สมมติว่าแมวของเรามีวิธีการที่ไม่คงที่meow() :

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

หากต้องการเรียกเมธอดนี้ เราจำเป็นต้องมีตัวอย่างเฉพาะของ cat:

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

41. อะไรคือข้อจำกัดหลักที่ใช้กับวิธีการแบบคงที่และไม่คงที่?

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

42. คำหลักคงที่หมายถึงอะไร? วิธีการคงที่สามารถแทนที่หรือโอเวอร์โหลดได้หรือไม่?

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

• สาขาของชั้นเรียน
• บล็อกการเริ่มต้นของคลาส
• วิธีการเรียน;
• คลาสที่ซ้อนกันของคลาส (แน่นอนว่านี่เป็นวิชาซ้ำซากด้วย)

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

43. วิธีการสามารถเป็นแบบคงที่และนามธรรมในเวลาเดียวกันได้หรือไม่?

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

44. สามารถใช้วิธีแบบคงที่ร่วมกับวิธีแบบไม่คงที่ได้หรือไม่? และในทางกลับกัน? ทำไม

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

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

ที่นี่เราจะเห็นว่าใน เมธอด petTheCat()แบบคงที่เรียกgetNameซึ่งเป็นเมธอดที่ไม่คงที่ทั่วไปของอ็อบเจ็กต์ Cat

45. อินเทอร์เฟซคืออะไร? สามารถมีอินเทอร์เฟซสุดท้ายได้หรือไม่?

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

public interface Animal {
    void speak();
}

ตัวอย่างการใช้งานอินเทอร์เฟซโดยคลาส

class Cat implements Animal {

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

สิ่งสำคัญที่ควรทราบเกี่ยวกับการใช้อินเทอร์เฟซมีดังนี้:

1. วิธีอินเทอร์เฟซต้องมีส่วนหัวเท่านั้น ต้องไม่มีเนื้อความของวิธีการเฉพาะ กล่าวคือ ต้องเป็นนามธรรม (แม้ว่าจะไม่ได้ใช้ คีย์เวิร์ด abstract ) มีข้อยกเว้น: วิธีการคงที่และวิธีการเริ่มต้นซึ่งจำเป็นต้องมีเนื้อหาของวิธีการ

2. คลาสสามารถใช้อินเทอร์เฟซได้หลายแบบ (อย่างที่ฉันบอกไปแล้วว่าอินเทอร์เฟซเป็นทางเลือกแทนการสืบทอดหลายรายการ) ชื่ออินเทอร์เฟซจะถูกคั่นด้วยเครื่องหมายจุลภาคในส่วนหัวของวิธีการ: คลาส Lion ดำเนินการ Animal, Wild

3. อินเทอร์เฟซถูกสร้างขึ้นโดยใช้คีย์เวิร์ดอินเทอร์ เฟซ

4. เมื่อคลาส Implement อินเทอร์เฟซ เราจะใช้คีย์เวิร์ดImplements

5. คลาสที่ใช้อินเทอร์เฟซบางอย่างต้องใช้วิธีนามธรรมทั้งหมดหรือต้องประกาศตัวเองว่าเป็นนามธรรม

6. วัตถุประสงค์หลักของการใช้อินเทอร์เฟซคือการใช้ความหลากหลาย (เพื่อให้วัตถุมีความสามารถในหลายรูปแบบ)

7. ตามกฎแล้ว ตัวแก้ไขการเข้าถึงสำหรับวิธีการจะไม่ถูกระบุในอินเทอร์เฟซ: เป็นสาธารณะตามค่าเริ่มต้น และคุณไม่สามารถระบุตัวแก้ไขอื่นนอกเหนือจากpublicได้ เริ่มต้นด้วย Java 9 คุณสามารถใช้ ตัวดัดแปลง ส่วนตัวกับเมธอดได้

8. ตามค่าเริ่มต้น ตัวแปรอินเทอร์เฟซจะเป็นแบบคงที่ในขั้นสุดท้าย กล่าวอีกนัยหนึ่ง มันเป็นค่าคงที่ — จะต้องเริ่มต้นโดยตรงในอินเทอร์เฟซเสมอ

9. คุณไม่สามารถสร้างอินสแตนซ์ของอินเทอร์เฟซได้

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

46. ​​ฟิลด์สแตติกสามารถเริ่มต้นได้ที่ไหน?

ฟิลด์แบบคงที่สามารถเริ่มต้นได้:

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

47. คลาสที่ไม่เปิดเผยตัวตนคืออะไร?

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

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

หากเราต้องการใช้คลาสที่ไม่ระบุตัวตนเพื่อสร้างอินสแตนซ์ของอินเทอร์เฟซที่กำหนด:

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

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

48. คลาสดั้งเดิมคืออะไร?

ฉันคิดว่านี่เป็นคำถามที่ทำให้เข้าใจผิด อาจเป็นคำถามหลอกลวง เนื่องจาก Java ไม่มีคลาสพื้นฐาน มีเพียงแนวคิดของประเภทดั้งเดิมที่เราพิจารณาก่อนหน้านี้ เราจำได้ ว่า Java มี 8 ประเภทดั้งเดิม: byte , short , int , long , float , double , char , boolean

49. คลาส wrapper คืออะไร?

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

• ไบต์ -> Byte.class
• สั้น -> Short.class
• int -> จำนวนเต็ม.class
• ยาว -> Long.class
• ลอย -> Float.class
• สองเท่า -> Double.class
• ถ่าน -> Character.class
• บูลีน -> Boolean.class

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

50. คลาสที่ซ้อนกันคืออะไร? มันใช้ที่ไหน?

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

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

ไม่ซับซ้อนใช่ไหม? ลองมาดูตัวอย่างของการสร้างอินสแตนซ์ของคลาสภายใน:

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

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

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

มันถูกสร้างขึ้นแตกต่างจากรุ่นก่อนหน้าเล็กน้อย:

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

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

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);
               ...

นี่คือตัวอย่าง:

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

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

51. คลาสสามารถมีตัวดัดแปลงการเข้าถึงอะไรได้บ้าง?

มีคลาสหลายประเภทและมีตัวดัดแปลงการเข้าถึงที่แตกต่างกัน:

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

นี่คือจุดที่เราจะสิ้นสุดในวันนี้ แล้วพบกันใหม่!