Java Inner Class ซึ่งเป็นแนวคิดที่คล้ายกันใน C ++ นั่นคือคลาสซ้อนกัน เมื่อมองแวบแรกชั้นเรียนภายในอาจดูซ้ำซ้อนเล็กน้อยและประโยชน์ของพวกเขาอาจไม่สำคัญสำหรับผู้เริ่มต้น แต่ด้วยความเข้าใจในเชิงลึกคุณจะพบว่านักออกแบบ Java มีเจตนาดีในชั้นเรียนภายใน การเรียนรู้ที่จะใช้คลาสภายในเป็นส่วนหนึ่งของการเรียนรู้การเขียนโปรแกรม Java ขั้นสูงซึ่งช่วยให้คุณออกแบบโครงสร้างโปรแกรมของคุณได้อย่างสง่างามยิ่งขึ้น ต่อไปนี้ได้รับการแนะนำจากด้านต่อไปนี้:
การประชุมครั้งแรก
เนื้อหาส่วนต่อประสานสาธารณะ {ค่า int ();} ปลายทางส่วนต่อประสานสาธารณะ {String readLabel ();} สินค้าคลาสสาธารณะ {เนื้อหาคลาสส่วนตัวใช้เนื้อหา {ส่วนตัว int i = 11; ค่า int สาธารณะ () {return i; }} คลาสที่ได้รับการป้องกัน GDESTINATE ใช้ปลายทาง {ฉลากสตริงส่วนตัว; Gdestination ส่วนตัว (String whereto) {label = whereto; } สตริงสาธารณะ readlabel () {return label; }} ปลายทางสาธารณะปลายทาง (สตริง s) {ส่งคืน gdestination ใหม่ (s); } เนื้อหาเนื้อหาสาธารณะ () {ส่งคืนเนื้อหาใหม่ (); }} คลาส testGoods {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {สินค้า p = สินค้าใหม่ (); สารบัญ c = p.cont (); ปลายทาง d = p.dest ("ปักกิ่ง"); -ในตัวอย่างนี้เนื้อหาคลาสและ GDESTINATE ถูกกำหนดไว้ในสินค้าชั้นเรียนและมีการป้องกันและปรับเปลี่ยนส่วนตัวตามลำดับเพื่อควบคุมระดับการเข้าถึง เนื้อหาแสดงถึงเนื้อหาของสินค้าในขณะที่ Gdestination แสดงถึงปลายทางของสินค้า พวกเขาใช้เนื้อหาอินเทอร์เฟซสองรายการและปลายทางตามลำดับ ในวิธีการหลักด้านล่างให้ใช้เนื้อหา C และปลายทาง D โดยตรงเพื่อทำงานและคุณไม่เห็นชื่อของคลาสภายในทั้งสองนี้! ด้วยวิธีนี้ประโยชน์แรกของชั้นเรียนภายในจะสะท้อนให้เห็น - ซ่อนการดำเนินการที่คุณไม่ต้องการให้คนอื่นรู้นั่นคือการห่อหุ้ม
ในเวลาเดียวกันเรายังค้นพบวิธีแรกที่จะได้รับวัตถุคลาสภายในนอกขอบเขตของคลาสภายนอกนั่นคือการใช้วิธีการของคลาสภายนอกเพื่อสร้างและส่งคืน นี่คือวิธีการ cont () และ dest () ในตัวอย่างข้างต้นทำ มีวิธีอื่นอีกไหม? แน่นอนรูปแบบไวยากรณ์มีดังนี้:
OUTEROBJECT = ใหม่ OUTERCLASS (พารามิเตอร์ตัวสร้าง); OUTERCLASS.InnerClass innerObject = outerObject.new InnerClass (พารามิเตอร์ตัวสร้าง);
โปรดทราบว่าเมื่อสร้างวัตถุคลาสภายในที่ไม่คงที่คุณต้องสร้างวัตถุชั้นนอกที่สอดคล้องกันก่อน ด้วยเหตุผลก็นำไปสู่หัวข้อต่อไปของเรา-
วัตถุชั้นในที่ไม่คงที่มีการอ้างอิงถึงวัตถุชั้นนอกของพวกเขา
การปรับเปลี่ยนตัวอย่างเล็กน้อยในตอนนี้:
สินค้าระดับสาธารณะ {การประเมินค่าส่วนตัว = 2; เนื้อหาคลาสส่วนตัวใช้เนื้อหา {ส่วนตัว int i = 11*การประเมินค่า; ค่า int สาธารณะ () {return i; }} คลาสที่ได้รับการป้องกัน GDESTINATE ใช้ปลายทาง {ฉลากสตริงส่วนตัว; Gdestination ส่วนตัว (String whereto) {label = whereto; } สตริงสาธารณะ readlabel () {return label; }} ปลายทางสาธารณะปลายทาง (สตริง s) {ส่งคืน gdestination ใหม่ (s); } เนื้อหาเนื้อหาสาธารณะ () {ส่งคืนเนื้อหาใหม่ (); -ส่วนที่แก้ไขจะแสดงเป็นสีแดง ที่นี่เราเพิ่มการประเมินค่าตัวแปรสมาชิกส่วนตัวลงในคลาสสินค้าซึ่งหมายถึงค่าสัมประสิทธิ์มูลค่าของสินค้า คูณเมื่อค่าเมธอดเนื้อหาคลาสภายใน () คำนวณค่า เราพบว่า value () สามารถเข้าถึงการประเมินค่าซึ่งเป็นประโยชน์ที่สองของคลาสภายใน - วัตถุคลาสชั้นในสามารถเข้าถึงเนื้อหาของวัตถุคลาสภายนอกที่สร้างขึ้นมารวมถึงตัวแปรส่วนตัว! นี่เป็นคุณสมบัติที่มีประโยชน์มากที่ให้แนวคิดและทางลัดมากขึ้นแก่เราเมื่อออกแบบ ในการใช้ฟังก์ชั่นนี้วัตถุคลาสภายในจะต้องมีการอ้างอิงไปยังวัตถุชั้นนอก เมื่อคอมไพเลอร์ Java สร้างวัตถุคลาสภายในมันจะส่งผ่านการอ้างอิงไปยังวัตถุคลาสภายนอกโดยปริยายและบันทึกตลอดเวลา สิ่งนี้ช่วยให้วัตถุคลาสภายในสามารถเข้าถึงวัตถุคลาสภายนอกของพวกเขาได้เสมอซึ่งเป็นสาเหตุที่อยู่นอกขอบเขตของการกระทำของคลาสภายนอกจะต้องสร้างวัตถุคลาสภายนอกก่อน
บางคนอาจถามว่าถ้าตัวแปรสมาชิกในคลาสด้านในเหมือนกับตัวแปรสมาชิกในชั้นนอกนั่นคือตัวแปรสมาชิกที่มีชื่อเดียวกันในคลาสด้านนอกถูกบล็อก? ไม่เป็นไร Java ใช้รูปแบบต่อไปนี้เพื่อแสดงการอ้างอิงไปยังคลาสภายนอก:
OUTERCLASS. นี่
ด้วยมันเราไม่กลัวสถานการณ์การปิดกั้นดังกล่าว
ชั้นในแบบคงที่
เช่นเดียวกับชั้นเรียนธรรมดาคลาสด้านในสามารถคงที่ อย่างไรก็ตามเมื่อเทียบกับชั้นเรียนที่ไม่คงที่ความแตกต่างคือคลาสชั้นในแบบคงที่ไม่มีการอ้างอิงถึงภายนอก จริง ๆ แล้วนี่คล้ายกับคลาสซ้อนกันใน C ++ ความแตกต่างที่ใหญ่ที่สุดระหว่างคลาส Java ภายในและคลาส C ++ ที่ซ้อนกันคือว่ามีการอ้างอิงถึงภายนอกหรือไม่ แน่นอนว่ามีความแตกต่างจากมุมมองของการออกแบบและรายละเอียดบางอย่างของมัน
นอกจากนี้ในชั้นเรียนภายในที่ไม่คงที่ใด ๆ ไม่สามารถมีข้อมูลคงที่วิธีการคงที่หรือคลาสภายในแบบคงที่อื่น (คลาสด้านในสามารถซ้อนกันได้มากกว่าหนึ่งชั้น) อย่างไรก็ตามชั้นเรียนภายในแบบคงที่สามารถมีทั้งหมดนี้ได้ นี่เป็นความแตกต่างที่สองระหว่างทั้งสอง
ชั้นเรียนภายในท้องถิ่น
ใช่คลาส Java ภายในสามารถเป็นท้องถิ่นและสามารถกำหนดได้ภายในวิธีการหรือแม้แต่บล็อกรหัส
ชั้นเรียนสาธารณะ 1 {ปลายทางสาธารณะปลายทาง (String S) {คลาส Gdestination ใช้ปลายทาง {ฉลากสตริงส่วนตัว; Gdestination ส่วนตัว (String whereto) {label = whereto; } สตริงสาธารณะ readlabel () {return label; }} ส่งคืน gdestination ใหม่; } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {goods1 g = สินค้าใหม่ 1 (); ปลายทาง d = g.dest ("ปักกิ่ง"); -นี่คือตัวอย่างด้านบน ในวิธีการที่เรากำหนดคลาสภายในและในที่สุดวิธีนี้จะส่งคืนวัตถุของคลาสภายในนี้ สิ่งนี้สามารถทำได้หากเราจำเป็นต้องสร้างหนึ่งในวัตถุและสร้างมันไปข้างนอกเมื่อใช้คลาสด้านใน แน่นอนคลาสภายในที่กำหนดไว้ในวิธีการสามารถกระจายการออกแบบและวัตถุประสงค์ไม่ได้เป็นเพียงแค่ในแง่นี้
นี่คือตัวอย่างที่แปลกประหลาดมากขึ้น:
ชั้นเรียนสาธารณะ 2 {โมฆะส่วนตัวภายในการติดตาม (บูลีน B) {ถ้า (b) {คลาส trackingslip {id สตริงส่วนตัว; trackingslip (สตริง s) {id = s; } สตริง getSlip () {return id; }} trackingslip ts = trackingslip ใหม่ ("สลิป"); สตริง s = ts.getSlip (); }} แทร็กโมฆะสาธารณะ () {internalTracking (จริง); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {goods2 g = สินค้าใหม่ 2 (); G.Track (); -คุณไม่สามารถสร้างวัตถุของคลาสภายในนี้นอก IF ได้เพราะนี่อยู่นอกเหนือขอบเขตของมัน อย่างไรก็ตามเมื่อรวบรวมการติดตามคลาสภายในจะถูกรวบรวมในเวลาเดียวกันกับคลาสอื่น ๆ แต่มันไม่ถูกต้องหากเกินขอบเขตนี้เนื่องจากขอบเขตของตัวเอง นอกเหนือจากนี้มันไม่แตกต่างจากชั้นเรียนอื่น ๆ
ชั้นเรียนภายในที่ไม่ระบุชื่อ
กฎไวยากรณ์ของคลาสภายในที่ไม่ระบุชื่อของ Java นั้นดูแปลก ๆ แต่เช่นเดียวกับอาร์เรย์ที่ไม่ระบุชื่อเมื่อคุณต้องการสร้างวัตถุของคลาสและไม่สามารถใช้ชื่อได้โดยใช้คลาสภายในสามารถทำให้รหัสดูกระชับและชัดเจน กฎไวยากรณ์มีดังนี้:
ใหม่ interfacename () {...... }; หรือ superclassName ใหม่ () {...... };มายกตัวอย่างต่อไป:
สินค้าระดับสาธารณะ 3 {เนื้อหาเนื้อหาสาธารณะ () {ส่งคืนเนื้อหาใหม่ () {ส่วนตัว int i = 11; ค่า int สาธารณะ () {return i; - -ที่นี่เมธอด cont () ใช้คลาสภายในที่ไม่ระบุชื่อเพื่อส่งคืนวัตถุที่ใช้คลาสของเนื้อหาอินเตอร์เฟสโดยตรงซึ่งดูกระชับมาก
ในอะแดปเตอร์นิรนามสำหรับการประมวลผลเหตุการณ์ใน Java ชั้นเรียนภายในที่ไม่ระบุชื่อจะถูกนำมาใช้กันอย่างแพร่หลาย ตัวอย่างเช่นเมื่อคุณต้องการปิดหน้าต่างให้เพิ่มรหัสนี้:
frame.addwindowListener (ใหม่ windowadapter () {โมฆะสาธารณะ windowclosing (windowevent e) {system.exit (0);}});สิ่งหนึ่งที่ควรทราบคือเนื่องจากคลาสภายในที่ไม่ระบุชื่อไม่มีชื่อมันไม่มีตัวสร้าง (แต่ถ้าคลาสภายในที่ไม่ระบุชื่อนี้สืบทอดคลาสพาเรนต์ที่มีเฉพาะคอนสตรัคเตอร์ที่มีอาร์กิวเมนต์คุณต้องนำพารามิเตอร์เหล่านี้เมื่อสร้างมัน หากคุณต้องการเริ่มต้นตัวแปรสมาชิกมีหลายวิธี:
หากเป็นคลาสภายในที่ไม่ระบุชื่อของวิธีการคุณสามารถใช้วิธีนี้เพื่อผ่านพารามิเตอร์ที่คุณต้องการ แต่โปรดจำไว้ว่าพารามิเตอร์เหล่านี้จะต้องประกาศขั้นสุดท้าย
ปฏิรูปชั้นเรียนที่ไม่ระบุชื่อในชั้นเรียนชั้นในที่มีชื่อเพื่อให้สามารถมีตัวสร้าง
ใช้บล็อกรหัสเริ่มต้นในคลาสภายในที่ไม่ระบุชื่อนี้
ทำไมชั้นเรียนภายในถึงต้องการ?
ประโยชน์ของชั้นเรียนภายใน Java คืออะไร? ทำไมชั้นเรียนภายในถึงต้องการ?
ก่อนอื่นให้ยกตัวอย่างง่ายๆ หากคุณต้องการใช้อินเทอร์เฟซ แต่วิธีหนึ่งในอินเทอร์เฟซนี้มีชื่อและพารามิเตอร์เดียวกับวิธีหนึ่งในคลาสที่คุณจินตนาการคุณควรทำอย่างไร ในเวลานี้คุณสามารถสร้างคลาสภายในเพื่อใช้อินเทอร์เฟซนี้ เนื่องจากคลาสด้านในสามารถเข้าถึงเนื้อหาทั้งหมดของคลาสด้านนอกได้การทำเช่นนั้นสามารถทำฟังก์ชั่นทั้งหมดที่คุณใช้โดยตรงกับอินเทอร์เฟซนี้โดยตรง
แต่คุณอาจต้องถามว่ามันไม่เพียงพอที่จะเปลี่ยนวิธีการหรือไม่
อันที่จริงมันไม่น่าเชื่อจริงๆที่จะใช้สิ่งนี้เป็นเหตุผลในการออกแบบหมวดหมู่ภายใน
เหตุผลที่แท้จริงคือคลาสและอินเทอร์เฟซภายในใน Java ถูกรวมเข้าด้วยกันเพื่อแก้ปัญหาที่มักจะถูกบดบังโดยโปรแกรมเมอร์ C ++ - ไม่มีการสืบทอดอีกต่อไป ในความเป็นจริงความหลากหลายของ C ++ นั้นซับซ้อนมากในการออกแบบและ Java สามารถบรรลุผลของการมีส่วนร่วมหลายเส้นผ่านคลาสภายในและอินเทอร์เฟซ
สรุปคลาส Java ภายใน
(1) ชั้นเรียนที่ไม่คงที่ที่กำหนดระหว่างวิธีการ:
●ชั้นเรียนต่อพ่วงและภายในสามารถเข้าถึงสมาชิกส่วนตัวของตนเองจากกันและกัน
●ตัวแปรสมาชิกคงที่ไม่สามารถกำหนดในคลาสด้านใน
นอกขอบเขตของคลาสภายนอกเพื่อสร้างวัตถุคลาสภายในคุณต้องสร้างวัตถุคลาสภายนอกก่อน
(2) คลาสภายในแบบคงที่ที่กำหนดระหว่างวิธีการ:
●สามารถเข้าถึงสมาชิกแบบคงที่ของชั้นเรียนภายนอกเท่านั้น
ชั้นเรียนชั้นในแบบคงที่ไม่มีการอ้างอิงถึงภายนอก
(3) คลาสภายในท้องถิ่นที่กำหนดไว้ในวิธีการ:
●คลาสภายในนี้ไม่มีสิทธิ์ในการควบคุมการเข้าถึงใด ๆ
●คลาสอุปกรณ์ต่อพ่วงไม่สามารถดูคลาสภายในท้องถิ่นในวิธีการ แต่คลาสภายในท้องถิ่นสามารถเข้าถึงสมาชิกใด ๆ ของคลาสอุปกรณ์ต่อพ่วง
●คลาสภายในท้องถิ่นสามารถเข้าถึงได้ใน Body Method แต่คำสั่งการเข้าถึงจะต้องเป็นหลังจากกำหนดคลาสภายในท้องถิ่น
●ชั้นเรียนภายในท้องถิ่นสามารถเข้าถึงค่าคงที่ในร่างกายของวิธีการนั่นคือสมาชิกแก้ไขด้วยขั้นสุดท้าย
(4) ชั้นเรียนที่ไม่ระบุชื่อที่กำหนดไว้ในวิธีการ:
●ไม่มีตัวสร้างแทนที่จะส่งผ่านพารามิเตอร์ตัวสร้างไปยังตัวสร้างซูเปอร์คลาส
เมื่อคุณต้องการสร้างวัตถุของคลาสและไม่ใช้ชื่อการใช้คลาสภายในที่ไม่ระบุชื่อสามารถทำให้รหัสดูกระชับและชัดเจน
บทความข้างต้นเข้าใจชั้นเรียนภายในและไม่ระบุชื่อใน Java เป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่ามันจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น