ชั้นเรียนภายใน Java
1. ความหมาย
ในภาษาการเขียนโปรแกรม Java โปรแกรมถูกสร้างขึ้นจากชั้นเรียน ชั้นเรียนยังสามารถประกาศภายในชั้นเรียนและเราเรียกคลาสชั้นในเช่นนี้
2. ฟังก์ชั่น
•การใช้การห่อหุ้มที่ดีขึ้นเรารู้ว่าตัวดัดแปลงการเข้าถึงสำหรับคลาสธรรมดา (คลาสที่ไม่ใช่ภายใน) ไม่สามารถเป็นส่วนตัวหรือได้รับการป้องกันในขณะที่คลาสภายในสามารถ เมื่อเราประกาศคลาสชั้นในเป็นส่วนตัวมีเพียงชั้นนอกเท่านั้นที่สามารถเข้าถึงคลาสด้านในซ่อนชั้นเรียนภายในได้อย่างดี
•คลาสภายในสามารถสืบทอด (ขยาย) หรือใช้ (ดำเนินการ) คลาสหรืออินเตอร์เฟสอื่น ๆ โดยไม่ได้รับผลกระทบจากคลาสภายนอก
•คลาสภายในสามารถเข้าถึงฟิลด์และวิธีการของคลาสภายนอกโดยตรงแม้ว่าจะมีการแก้ไขด้วยส่วนตัว ในทางตรงกันข้ามคลาสภายนอกไม่สามารถเข้าถึงสมาชิกของชั้นเรียนภายในได้โดยตรง
3. หลักการ
ชั้นเรียนภายในเป็นแนวคิดการรวบรวมเวลา หลังจากการรวบรวมไฟล์คลาสอิสระสองไฟล์จะถูกสร้างขึ้นดังนี้:
ชั้นเรียนสาธารณะ {สตริงส่วนตัว outername = "Outer"; คลาส Inner {Private String Innername = "Inner"; -ไฟล์ที่รวบรวมมีดังนี้:
หลังจากการรวบรวมแล้ว Outer.inner จะถูกเปลี่ยนชื่อเป็นด้านนอก $ inner และระยะเวลา (.) จะถูกแทนที่ด้วยเครื่องหมายดอลลาร์ ($)
iv. การจำแนกประเภท
คลาสภายในของ Java สามารถแบ่งออกเป็นคลาสภายในคลาสคลาสภายในชั้นเรียนภายในคลาสภายในที่ไม่ระบุชื่อและคลาสภายในแบบคงที่
1) ชั้นเรียนภายในของสมาชิก
คลาสสมาชิกภายในสามารถถือได้ว่าเป็นสมาชิกของคลาสภายนอก สมาชิกคงที่ไม่สามารถประกาศในคลาสสมาชิกภายใน แต่ฟิลด์สุดท้ายคงที่เป็นข้อยกเว้น เรารู้ว่าเมื่อมีการโหลดคลาสสมาชิกคงที่จะเริ่มต้นก่อน หากคลาสภายในของสมาชิกมีสมาชิกแบบคงที่คลาสภายในจะถูกสร้างขึ้นก่อนคลาสภายนอก คลาสด้านในให้บริการคลาสภายนอกและคลาสด้านในที่สร้างขึ้นก่อนคลาสภายนอกอาจไม่สามารถควบคุมได้ เมื่ออินสแตนซ์คลาสภายในคลาสสมาชิกชั้นในจะมีการอ้างอิงไปยังวัตถุปัจจุบันของคลาสภายนอกเพื่อให้สมาชิกของคลาสภายนอกสามารถเข้าถึงได้โดยตรงในคลาสภายในของสมาชิกแม้ว่าจะมีการแก้ไขส่วนตัวก็ตาม
นำเข้า Java.lang.System.OUT; ชั้นเรียนสาธารณะ {สตริงส่วนตัว outername = "Outer"; // คลาสภายนอกไม่สามารถเข้าถึงสมาชิกของคลาสด้านในโดยตรงและจำเป็นต้องสร้างอินสแตนซ์อินเนอร์อินเนอร์ภายใน INNER ภายใน = new Inner (); ชั้นเรียนสาธารณะชั้นใน {สตริงส่วนตัว innername = "inner"; โมฆะสาธารณะแสดง () {out.println (outername); // คุณสามารถเข้าถึงสมาชิกของชั้นนอกได้โดยตรง}} โมฆะสาธารณะแสดง () {out.println (inner.innername); inner.show (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {Outer Outer = new Outer (); OUTER.SHOW (); // อินสแตนซ์คลาสด้านในด้านนอก. inner inner = outer.new inner (); inner.show (); -ผลการทำงาน:
ภายใน
ด้านนอก
ด้านนอก
การอ้างอิงถึงวัตถุคลาสภายนอกของคลาสสมาชิกภายในประกอบด้วยชื่อของคลาสภายนอกก่อนหน้านี้ แบบฟอร์มนี้เรียกว่า
จำกัด-this, out.println (outername) และ out.println (outer.his.outername) เทียบเท่า
2) ชั้นเรียนภายในท้องถิ่น
การใช้คลาสชั้นในในท้องถิ่นนั้นเหมือนกับคลาสภายในของสมาชิก มันเป็นเพียงการกำหนดคลาสภายในในพื้นที่ถูกกำหนดไว้ในวิธีการของคลาสภายนอกเช่นเดียวกับตัวแปรท้องถิ่นและไม่ใช่สมาชิกของคลาสภายนอก คลาสภายในท้องถิ่นไม่สามารถเข้าถึงได้นอกวิธีการ แต่อินสแตนซ์ของมันสามารถส่งคืนจากวิธีการและอินสแตนซ์จะยังคงอยู่จนกว่าพวกเขาจะไม่ถูกอ้างอิงอีกต่อไป คลาสภายในท้องถิ่นยังสามารถเข้าถึงตัวแปรท้องถิ่นพารามิเตอร์วิธี ฯลฯ ของวิธีการที่พวกเขาอยู่ ข้อ จำกัด คือตัวแปรท้องถิ่นหรือพารามิเตอร์วิธีการสามารถเข้าถึงได้เมื่อประกาศว่าเป็นขั้นสุดท้ายเท่านั้น
นำเข้า Java.lang.System.OUT; ชั้นเรียนสาธารณะ {สตริงส่วนตัว outername = "Outer"; โมฆะสาธารณะแสดง (สตริงสุดท้าย str) {// พารามิเตอร์วิธีการเป็นคลาสประเภทสุดท้ายชั้นใน {public void print () {out.println (outername+str); }} inner inner = new inner (); inner.print (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {Outer Outer = new Outer (); OUTER.SHOW (": LALALA"); -ผลการทำงาน:
ด้านนอก: Lalala
3) คลาสภายในที่ไม่ระบุชื่อ
คุณสามารถจินตนาการคลาสภายในที่ไม่ระบุชื่อเป็นคลาสภายในภายในที่ไม่มีชื่อคลาส คลาสภายในที่ไม่ระบุชื่อมีลักษณะดังต่อไปนี้:
1. คลาสภายในที่ไม่ระบุชื่อไม่สามารถมีตัวสร้างได้ คลาสภายในที่ไม่ระบุชื่อไม่มีชื่อคลาสดังนั้นตัวสร้างไม่สามารถประกาศได้
2. คลาสภายในที่ไม่ระบุชื่อจะต้องสืบทอดหรือใช้อินเทอร์เฟซ ประเภทที่ได้รับมอบหมายให้ใหม่คือ supertype ของคลาสที่ไม่ระบุชื่อ คลาสที่ไม่ระบุชื่อไม่สามารถขยายหรือดำเนินการได้ที่แสดงและไม่สามารถมีตัวดัดแปลงใด ๆ ได้
3. ชั้นเรียนภายในที่ไม่ระบุชื่อเหมือนกับคลาสภายในของสมาชิกและชั้นเรียนภายในท้องถิ่นและไม่สามารถประกาศสมาชิกแบบคงที่
นำเข้า Java.lang.System.OUT; ชั้นเรียนสาธารณะ {สตริงส่วนตัว outername = "Outer"; การแสดงโมฆะสาธารณะ (สตริงสุดท้าย str) {new inner () {// ใช้อินเตอร์เฟสภายใน public print () {out.println (outername+str); }} .print (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {Outer Outer = new Outer (); OUTER.SHOW (": LALALA"); }} อินเตอร์เฟสภายใน {void print (); -ผลการทำงาน:
ด้านนอก: Lalala
4) ชั้นเรียนภายใน
ชั้นเรียนชั้นในแบบคงที่หรือที่เรียกว่าคลาสซ้อนในหนังสือบางเล่มต้องใช้ตัวดัดแปลงแบบคงที่เมื่อประกาศ คลาสภายในแบบคงที่นั้นแตกต่างจากชั้นเรียนสามชั้นแรก คลาสภายในแบบคงที่ไม่ได้มีการอ้างอิงถึงวัตถุปัจจุบันของชั้นนอกดังนั้นสมาชิกที่ไม่คงที่ของคลาสด้านนอกไม่สามารถเข้าถึงได้ในชั้นเรียนภายในแบบคงที่ อาจกล่าวได้ว่าชั้นเรียนชั้นในแบบคงที่ไม่ได้ขึ้นอยู่กับชั้นนอก
นำเข้า Java.lang.System.OUT; ชั้นเรียนสาธารณะ {สตริงส่วนตัว outername = "Outer"; ID int คงที่ส่วนตัว = 123; Inner Inner ส่วนตัว = new Inner (); ชั้นเรียนคงที่สาธารณะภายใน {โมฆะสาธารณะ print1 () {//out.println(outername); ไม่สามารถเข้าถึงสมาชิกที่ไม่คงที่ของคลาสภายนอกได้ } โมฆะคงที่สาธารณะ print2 () {out.println (id); }} โมฆะสาธารณะแสดง () {inner.print1 (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {Outer Outer = new Outer (); OUTER.SHOW (); OUTER.INNER.PRINT2 (); // การเข้าถึงคลาสภายในแบบคงที่ผ่านชื่อคลาส}}}