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

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

39. Access Modifiers ใน Java คืออะไร? ตั้งชื่อพวกเขา พวกเขาใช้ทำอะไร?

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

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

40. ตั้งชื่อคุณลักษณะหลักของวิธีคงที่และตัวแปร

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

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Погладить кота - " + cat.getName());
   }

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

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

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

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

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

Cat cat = new Cat(7, "Bobi");
cat.mew();

41. อะไรคือข้อจำกัดหลักสำหรับวิธีคงที่และวิธี "ตัวแปร"?

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

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

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

• ฟิลด์คลาส;
• บล็อกการเริ่มต้นคลาส
• วิธีการเรียน
• คลาสภายในของคลาส (อย่างไรก็ตาม นั่นยังคงเป็นเรื่องซ้ำซาก)

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

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

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

44. เป็นไปได้ไหมที่จะใช้วิธีคงที่ระหว่างวิธีปกติ? ในทางกลับกัน? ทำไม

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

public static void petTheCat(Cat cat) {
   System.out.println("Погладить кота - " + cat.getName());
}

ที่นี่เรา จะ เห็นว่าเมธอดคงที่petTheCatเรียกเมธอดปกติและไม่คงที่ของ วัตถุ Cat - getName

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

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

public interface Animal {
    void voice();
}

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

class Cat implements Animal {

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

สิ่งสำคัญที่คุณต้องรู้เกี่ยวกับการใช้อินเทอร์เฟซคือ:

1. วิธีการอินเทอร์เฟซควรมีเฉพาะส่วนหัว โดยไม่มีเนื้อหาของวิธีการเฉพาะ เช่น ต้องเป็นนามธรรม (แต่โดยไม่ต้องใช้ abstractคำหลัก) ข้อยกเว้นนี้คือวิธีการแบบคงที่และเป็นค่าเริ่มต้น ซึ่งจำเป็นต้องมีเนื้อหาของวิธีการ
2. คลาสสามารถใช้อินเทอร์เฟซได้มากมาย (อย่างที่ฉันบอกไปแล้วว่านี่เป็นทางเลือกแทนการสืบทอดหลายรายการ) ซึ่งเขียนโดยคั่นด้วยเครื่องหมายจุลภาค: คลาส Lion ใช้งาน Animal, Wild
3. อินเทอร์เฟซถูกสร้างขึ้นโดยใช้คำหลัก - อินเทอร์เฟซ
4. เมื่อนำอินเทอร์เฟซไปใช้โดยคลาส คีย์เวิร์ดจะถูกใช้ - นำไปใช้
5. คลาสที่ใช้อินเทอร์เฟซเฉพาะจะต้องใช้วิธีการนามธรรมทั้งหมดหรือต้องประกาศตัวเองว่าเป็นนามธรรม
6. วัตถุประสงค์หลักของการใช้อินเทอร์เฟซคือการใช้ความหลากหลาย (ความสามารถของวัตถุที่มีหลายรูปแบบ)
7. ตามกฎแล้ว ตัวแก้ไขการเข้าถึงสำหรับวิธีการจะไม่ถูกเขียนในอินเทอร์เฟซ: เป็นสาธารณะ ตามค่าเริ่มต้น และ ไม่สามารถระบุตัวแก้ไขอื่น ๆ นอกเหนือจากสาธารณะ ได้ ตั้งแต่ Java 9 คุณสามารถใช้ ตัวดัดแปลง ส่วนตัวสำหรับวิธีการได้
8. ตัวแปรอินเทอร์เฟซ จะเป็นค่าคงที่สุดท้ายตามค่าเริ่มต้นหรืออีกนัยหนึ่งคือค่าคงที่ ซึ่งจำเป็นต้องเริ่มต้นโดยตรงในอินเทอร์เฟซเสมอ
9. คุณไม่สามารถสร้างวัตถุอินเทอร์เฟซได้

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

46. ​​​​ฉันสามารถเริ่มต้นฟิลด์คงที่ได้ที่ไหน?

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

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

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

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

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

หากเราต้องการสร้างอินสแตนซ์อินเทอร์เฟซนี้ผ่านคลาสที่ไม่ระบุชื่อ:

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

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

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

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

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

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

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

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

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

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

public class Zoo {
   class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

ไม่มีอะไรซับซ้อนใช่ไหม? ลองมาดูตัวอย่างการสร้างวัตถุคลาสภายใน:

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.toFeed("яблоко");

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

public class Zoo {
   static class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

วิธีการสร้างแตกต่างจากวิธีก่อนหน้าเล็กน้อย:

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.toFeed("яблоко");

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

public class Zoo {
   public void toFeed(String animal, String food) {
       switch(animal){
           case "зебра":
               class Zebra {
                   void toFeedZebra(String food) {
                       System.out.println("Дать зебре - " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.toFeedZebra(food);
               ...

ตัวอย่างการใช้งาน:

Zoo zoo = new Zoo();
zoo.toFeed("зебра", "яблоко");

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

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

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

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

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