เมื่อเร็ว ๆ นี้เพื่อนคนหนึ่งบอกว่าเขาอยากจะบอกว่าเขากำลังเรียนรู้ Java เมื่อเร็ว ๆ นี้ เขายังไม่เข้าใจภาษาการเขียนโปรแกรมเชิงวัตถุ เพื่อช่วยให้เขา "เปลี่ยน" เร็วขึ้นฉันเขียนบทความนี้ เพราะจากระดับโครงสร้าง ความคิดของภาษาการเขียนโปรแกรมเชิงวัตถุทั้งหมดมีความคล้ายคลึงกันและลักษณะทั้งสามนี้เป็นเสาหลักในการคิด ต่อไปฉันจะมุ่งเน้นไปที่การอธิบายลักษณะสำคัญสามประการของ Java
ภาษาการเขียนโปรแกรมเชิงวัตถุมีคุณสมบัติหลักสามประการ: "การห่อหุ้ม", "การสืบทอด" และ "polymorphism"
บรรจุุภัณฑ์
ในการเขียนโปรแกรมเชิงวัตถุการห่อหุ้ม (encapsulation) เป็นความหมายของบรรจุภัณฑ์อย่างแท้จริงซึ่งหมายถึงการใช้ชนิดข้อมูลนามธรรมเพื่อห่อหุ้มข้อมูลและการดำเนินการตามข้อมูลด้วยกันทำให้พวกเขาเป็นนิติบุคคลอิสระที่แยกออกไม่ได้ ในความเป็นจริงมันคือการห่อหุ้มวิธีการและข้อมูลที่จำเป็นสำหรับวัตถุที่จะเรียกใช้ในโปรแกรมเพื่อเผยแพร่อินเทอร์เฟซ ข้อมูลได้รับการปกป้องภายในชนิดข้อมูลนามธรรมซ่อนรายละเอียดภายในให้มากที่สุดเท่าที่จะเป็นไปได้และรักษาอินเทอร์เฟซภายนอกบางส่วนเพื่อให้ติดต่อด้านนอก กล่าวอีกนัยหนึ่งผู้ใช้ไม่จำเป็นต้องทราบรายละเอียดภายในวัตถุ (แน่นอนไม่มีวิธีที่จะรู้) แต่วัตถุสามารถเข้าถึงได้ผ่านอินเทอร์เฟซที่ให้โดยวัตถุด้านนอก ในแง่ของคนธรรมดาวัตถุอื่น ๆ ที่แนบมากับอินเทอร์เฟซเหล่านี้ไม่จำเป็นต้องใส่ใจเกี่ยวกับการใช้งานวัตถุเพื่อใช้วัตถุนี้ แนวคิดคือ "อย่าบอกฉันว่าคุณทำได้อย่างไรแค่ทำมัน"
ดังนั้นการห่อหุ้มจึงเป็นการแปรรูปคุณสมบัติของวัตถุและให้วิธีการบางอย่างของแอตทริบิวต์ที่สามารถเข้าถึงได้โดยโลกภายนอก หากเราไม่ต้องการเข้าถึงโดยโลกภายนอกเราไม่จำเป็นต้องให้วิธีการเข้าถึงโดยโลกภายนอก แต่ถ้าชั้นเรียนไม่มีวิธีการให้กับโลกภายนอกเพื่อเข้าถึงคลาสนี้ไม่มีความหมาย
ตัวอย่างเช่นเราถือว่าวัตถุเป็นบ้านและวอลล์เปเปอร์ที่สวยงามภายในเช่นโซฟาทีวีเครื่องปรับอากาศ ฯลฯ ล้วนเป็นคุณลักษณะส่วนตัวของบ้าน แต่ถ้าไม่มีผนังครอบคลุมแล้วก็ไม่มีความเป็นส่วนตัวเลย! เป็นเพราะกำแพงปิดกั้นที่เราไม่เพียง แต่มีความเป็นส่วนตัวของเราเอง แต่ยังเปลี่ยนการตกแต่งภายในตามที่ต้องการโดยไม่ส่งผลกระทบต่อผู้อื่น แต่ถ้าไม่มีประตูและหน้าต่างความหมายของกล่องดำที่ห่อหุ้มอย่างแน่นหนาคืออะไร? ดังนั้นคนอื่น ๆ ก็สามารถเห็นทิวทัศน์ภายในผ่านประตูและหน้าต่าง ดังนั้นประตูและหน้าต่างจึงเป็นอินเทอร์เฟซที่เหลืออยู่โดยวัตถุของบ้านเพื่อให้โลกภายนอกเข้าถึงได้
โดยทั่วไปควรเพิ่มตัวดัดแปลงส่วนตัวก่อนที่แอตทริบิวต์ในชั้นเรียน จากนั้นกำหนดวิธี getter และ setter จากนั้นวัตถุในฟังก์ชั่นหลักของเราไม่สามารถเรียกคุณสมบัติโดยตรงได้อีกต่อไปและสามารถเรียกใช้วิธี getter และ setter เท่านั้น
มีประโยชน์สามประการของบรรจุภัณฑ์
1. แพ็คเกจที่ดีสามารถลดการมีเพศสัมพันธ์ได้
2. โครงสร้างภายในชั้นเรียนสามารถแก้ไขได้อย่างอิสระ
3. การควบคุมสมาชิกที่แม่นยำยิ่งขึ้นสามารถให้ได้
4. ซ่อนข้อมูลและใช้รายละเอียด
ตัวดัดแปลง
ก่อนอื่นคุณต้องเข้าใจว่าตัวดัดแปลงคืออะไร ตัวดัดแปลงการเข้าถึงสามารถใช้ในการปรับเปลี่ยนขอบเขตการเข้าถึงของแอตทริบิวต์และวิธีการ
ในกระบวนการเชิงวัตถุเราใช้การควบคุมการอนุญาตเพื่อเพิ่มการอนุญาตให้กับคลาสที่ห่อหุ้มเพื่อ จำกัด การจัดการของคนนอกในชั้นเรียนเพื่อให้มั่นใจในความปลอดภัยของข้อมูลและวิธีการในชั้นเรียน อาจกล่าวได้ว่าคลาสเป็นเอนทิตีตรรกะที่ห่อหุ้มคุณลักษณะและวิธีการที่เกี่ยวข้อง สำหรับคุณสมบัติหรือวิธีการบางอย่างในวัตถุพวกเขาสามารถเป็นส่วนตัวและไม่สามารถเข้าถึงได้โดยโลกภายนอก นอกจากนี้ยังสามารถแบ่งปันและสามารถเข้าถึงได้โดยบุคคลภายนอก ด้วยวิธีนี้วัตถุให้ระดับการป้องกันที่แตกต่างกันสำหรับข้อมูลภายในเพื่อป้องกันไม่ให้ส่วนที่ไม่เกี่ยวข้องของโปรแกรมจากการเปลี่ยนแปลงโดยไม่ตั้งใจหรือใช้ส่วนส่วนตัวของวัตถุอย่างไม่ถูกต้องทำให้เกิดข้อผิดพลาดที่ไม่จำเป็นในโปรแกรม
ตัวดัดแปลงใน Java เป็นที่สาธารณะได้รับการคุ้มครองค่าเริ่มต้นและส่วนตัว สิ่งนี้แสดงให้เห็นถึงการห่อหุ้มที่มุ่งเน้นวัตถุและเราต้องพยายามอย่างเต็มที่เพื่อลดการอนุญาตให้น้อยที่สุดเพื่อปรับปรุงความปลอดภัย
ดังที่แสดงในรูปมันแสดงถึงขอบเขตการเข้าถึงของตัวดัดแปลงการเข้าถึงที่แตกต่างกันเช่นคุณสมบัติหรือวิธีการที่แก้ไขโดยส่วนตัวซึ่งสามารถเข้าถึงหรือใช้ในคลาสนี้เท่านั้น หากไม่มีการเพิ่ม modifier ค่าเริ่มต้นเป็นค่าเริ่มต้นและสามารถเข้าถึงและใช้โดยค่าเริ่มต้นในคลาสปัจจุบันและแพ็คเกจเดียวกัน
การเข้าถึงสิทธิ์การเข้าถึงคลาส Subclass แพ็คเกจอื่น ๆ
สาธารณะ∨∨∨
ปกป้อง∨∨××
ค่าเริ่มต้น∨∨××
ส่วนตัว∨×××
หากไม่มีการเพิ่ม modifier ก่อนที่แอตทริบิวต์การอนุญาตเริ่มต้นจะเป็นค่าเริ่มต้น เราสามารถแก้ไขค่าแอตทริบิวต์โดยตรงโดยการสร้างวัตถุและลักษณะการห่อหุ้มจะไม่สะท้อน สิ่งนี้ไม่ปลอดภัยในการเขียนโปรแกรมดังนั้นเราจึงต้องใช้การห่อหุ้มเพื่อปรับปรุงรหัสของเรา
ตัวอย่างของตัวดัดแปลง
ก่อนอื่นเรากำหนดสี่ชั้นเรียนผู้ปกครองครูนักเรียนและเปรียบเทียบความแตกต่างระหว่างแพ็คเกจอื่น ๆ คลาสย่อยแพ็คเกจและคลาสนี้ แผนภาพตำแหน่งของแต่ละชั้นจะแสดงขึ้น
แพ็คเกจ com.java.test; บุคคลระดับสาธารณะ {ชื่อสตริงสาธารณะ = "จางซาน"; โมฆะสาธารณะแนะนำตัว () {System.out.println (ชื่อ); -ชื่อคือสาธารณะ หากไม่มีข้อผิดพลาดในการรวบรวมหมายความว่าตัวแปรสาธารณะสามารถเข้าถึงคลาสนี้ได้
แพ็คเกจ com.java.test; นักเรียนชั้นเรียนสาธารณะ {person p = บุคคลใหม่ (); การทดสอบโมฆะสาธารณะ () {System.out.println (P.Uname); -นักเรียนและบุคคลอยู่ในแพ็คเกจเดียวกัน หากไม่มีข้อผิดพลาดในการรวบรวมหมายความว่าตัวแปรมีสิทธิ์การเข้าถึงในแพ็คเกจเดียวกัน
แพ็คเกจ com.java.test1; นำเข้า com.java.test.person; ครูระดับสาธารณะขยายบุคคล {อายุ int สาธารณะ; บุคคล p = คนใหม่ (); โมฆะสาธารณะ test1 () {system.out.println (P.Uname); -นักเรียนและบุคคลไม่ได้อยู่ในแพ็คเกจเดียวกัน แต่ครูสืบทอดชั้นเรียนบุคคล หากไม่มีข้อผิดพลาดในการรวบรวมหมายความว่าตัวแปรมีสิทธิ์การเข้าถึงในแพ็คเกจย่อย
แพ็คเกจ com.java.test1; นำเข้า com.java.test.person; ผู้ปกครองระดับสาธารณะ {public String Uname = "HAHA"; บุคคล p = คนใหม่ (); โมฆะสาธารณะ test2 () {system.out.println (P.Uname); -ผู้ปกครองและบุคคลไม่ได้อยู่ในแพ็คเกจเดียวกัน หากไม่มีข้อผิดพลาดในการรวบรวมหมายความว่าตัวแปรไม่มีสิทธิ์การเข้าถึง
หลังจากการทดสอบข้างต้นหากพวกเขาทั้งหมดสามารถรวบรวมและผ่านได้หมายความว่าคลาสที่แก้ไขด้วยสาธารณะสามารถเข้าถึงซึ่งกันและกันในคลาสนี้แพ็คเกจเดียวกัน subclass และแพ็คเกจอื่น ๆ
นอกจากนี้เรายังเริ่มทดสอบปัญหาการอนุญาตที่ได้รับการป้องกัน หากบุคคลครูและนักเรียนสามารถรวบรวมและผ่านได้หมายความว่าชั้นเรียนที่แก้ไขด้วยการป้องกันสามารถเข้าถึงซึ่งกันและกันในชั้นเรียนนี้แพ็คเกจเดียวกันและคลาสย่อย หากผู้ปกครองไม่ได้รวบรวมและไม่ผ่านนั่นหมายความว่าการป้องกันไม่สามารถเข้าถึงซึ่งกันและกันในชั้นเรียนโดยไม่มีความสัมพันธ์ระหว่างการสืบทอดนอกแพ็คเกจ
เริ่มทดสอบปัญหาการอนุญาตเริ่มต้น หากบุคคลและนักเรียนสามารถรวบรวมและผ่านได้หมายความว่าคลาสที่แก้ไขด้วยค่าเริ่มต้นสามารถเข้าถึงซึ่งกันและกันในชั้นเรียนนี้แพ็คเกจเดียวกันและคลาสย่อย การคอมไพล์ผู้ปกครองและครูโดยไม่ต้องผ่านชั้นเรียนพ่อแม่และครูไม่สามารถเข้าถึงซึ่งกันและกันโดยไม่คำนึงว่ามีความสัมพันธ์ในการสืบทอดหรือไม่
นอกจากนี้เรายังเริ่มทดสอบปัญหาการอนุญาตส่วนตัว หากบุคคลสามารถรวบรวมและผ่านได้หมายความว่าคลาสที่แก้ไขด้วยส่วนตัวสามารถเข้าถึงซึ่งกันและกันในคลาสนี้แพ็คเกจเดียวกันและคลาสย่อย ผู้ปกครองครูและนักเรียนไม่สามารถรวบรวมได้โดยไม่ต้องผ่านส่วนตัวเพื่อระบุว่าชั้นเรียนที่แก้ไขด้วยส่วนตัวสามารถเข้าถึงได้ในชั้นเรียนนี้เท่านั้น
โดยทั่วไปควรเพิ่มตัวดัดแปลงส่วนตัวก่อนที่แอตทริบิวต์ในชั้นเรียน จากนั้นกำหนดวิธี getter และ setter จากนั้นวัตถุในฟังก์ชั่นหลักของเราไม่สามารถเรียกคุณสมบัติโดยตรงได้อีกต่อไปและสามารถเรียกใช้วิธี getter และ setter เท่านั้น
ถุง
ให้ฉันบอกคุณฟังก์ชั่นของกระเป๋า
บางครั้งเมื่อคุณพบชื่อคลาสของโปรแกรมอาจซ้ำกันเราสามารถใช้แนวคิดของแพ็คเกจเพื่อแก้ปัญหาของเรา วัตถุประสงค์ของแพ็คเกจคือการจัดการไฟล์ Java และแก้ไขข้อขัดแย้งของไฟล์ด้วยชื่อเดียวกัน สิ่งนี้คล้ายกับตู้เสื้อผ้า เรามีพาร์ติชันและลิ้นชักที่แตกต่างกันในตู้เสื้อผ้าหรือไม่? เราวางเสื้อผ้าแยกต่างหากในหมวดหมู่ที่แตกต่างกันซึ่งเอื้อต่อการจัดการของเรา
ในการกำหนดแพ็คเกจเราใช้คำหลักแพ็คเกจรวมถึงชื่อแพ็คเกจของเรา
แพ็คเกจ com.java.test; // หมายเหตุ: จะต้องวางไว้ในบรรทัดแรกของโปรแกรมต้นทางและชื่อแพ็คเกจสามารถคั่นด้วย "." เข้าสู่ระบบ. ข้อกำหนดการตั้งชื่อของแพ็คเกจถูกสะกดด้วยตัวอักษรตัวพิมพ์เล็กทั้งหมด
แพ็คเกจที่ใช้กันทั่วไปในระบบ Java
java. (ฟังก์ชั่น). (คลาส) java.lang. (คลาส) มีพื้นฐานของภาษา Java java.util. (คลาส) มีคลาสเครื่องมือต่าง ๆ ในภาษา Java.io. (คลาส) มีคลาสที่เกี่ยวข้องกับอินพุตและเอาต์พุต
ในการใช้คลาสในไฟล์อื่นในแพ็คเกจที่แตกต่างกันคุณต้องใช้คำหลักนำเข้า ตัวอย่างเช่นนำเข้า com.java.test1.test.java ในเวลาเดียวกันหากนำเข้า com.java.test1*นำเข้าไฟล์ทั้งหมดภายใต้แพ็คเกจ
คำหลักนี้
1. แอปพลิเคชั่นหลักสามข้อของคำหลักนี้:
(1) สิ่งนี้เรียกคุณลักษณะในคลาสนี้นั่นคือตัวแปรสมาชิกในชั้นเรียน
(2) สิ่งนี้เรียกวิธีการอื่นในคลาสนี้
(3) การเรียกตัวสร้างอื่น ๆ ในคลาสนี้และควรวางไว้ในบรรทัดแรกของตัวสร้างเมื่อโทร
นักเรียนชั้นเรียนสาธารณะ {นักเรียนสาธารณะ (ชื่อสตริง) {// กำหนดคอนสตรัคเตอร์ที่มีพารามิเตอร์อย่างเป็นทางการ} นักเรียนสาธารณะ () {// กำหนดวิธีการชื่อเหมือนกับชั้นเรียนดังนั้นมันจึงเป็นตัวสร้างสิ่งนี้ ("สวัสดี!"); } ชื่อสตริง; // กำหนดชื่อตัวแปรสมาชิกโมฆะส่วนตัว setName (ชื่อสตริง) {// กำหนดพารามิเตอร์ (ตัวแปรโลคอล) ชื่อ this.name = ชื่อ; // ส่งค่าของตัวแปรโลคัลไปยังตัวแปรสมาชิก}}ในรหัสข้างต้นมีชื่อตัวแปรสมาชิกและมีพารามิเตอร์อย่างเป็นทางการในวิธีการและชื่อก็เป็นชื่อ จากนั้นค่าของชื่อพารามิเตอร์ที่เป็นทางการจะถูกส่งผ่านไปยังชื่อตัวแปรสมาชิกในวิธีการ
คำหลักนี้แสดงถึงตัวแปรสมาชิกหรือวิธีการในวัตถุ กล่าวคือหากมีการเพิ่มตัวแปรด้วยคำหลักนี้มันหมายถึงตัวแปรสมาชิกหรือวิธีการของวัตถุแทนที่จะเป็นพารามิเตอร์ที่เป็นทางการหรือตัวแปรท้องถิ่นของวิธีการสมาชิก ด้วยเหตุผลนี้ในรหัสข้างต้นชื่อนี้แสดงถึงตัวแปรสมาชิกในวัตถุหรือที่เรียกว่าคุณสมบัติของวัตถุและชื่อที่ตามมาคือพารามิเตอร์ที่เป็นทางการของวิธีการ รหัส this.name = ชื่อคือการผ่านค่าของพารามิเตอร์อย่างเป็นทางการไปยังตัวแปรสมาชิก
หากมีตัวสร้างหลายตัวในชั้นเรียนเพราะชื่อของพวกเขาเหมือนกันและเหมือนกับชื่อคลาสแล้วตัวสร้างนี้เรียกว่า ในความเป็นจริงนี่เป็นเช่นเดียวกับการใช้วิธีอื่น ๆ เพื่ออ้างถึงตัวสร้างและพวกเขาจะถูกเรียกผ่านพารามิเตอร์ที่เป็นทางการ ดังในตัวอย่างข้างต้นหากมีการเพิ่มพารามิเตอร์หลังจากคำหลักนี้หมายความว่ามันหมายถึงตัวสร้างที่มีพารามิเตอร์ หากมีวิธีการก่อสร้างสามวิธีคือไม่มีพารามิเตอร์พารามิเตอร์หนึ่งพารามิเตอร์และพารามิเตอร์สองตัว จากนั้นคอมไพเลอร์ Java จะกำหนดตัวสร้างที่จะโทรตามจำนวนพารามิเตอร์ที่ผ่าน ดังที่เห็นได้จากตัวอย่างข้างต้นคำหลักนี้สามารถใช้ไม่เพียง แต่เพื่ออ้างอิงตัวแปรสมาชิกเท่านั้น แต่ยังรวมถึงตัวสร้างอ้างอิง
ชั้นเรียนภายใน
ชั้นเรียนชั้นในเป็นเรื่องง่ายที่จะเข้าใจจากภายนอก คลาสภายในคือการวางคำจำกัดความของคลาสหนึ่งภายในนิยามของคลาสอื่น แน่นอนว่าสอดคล้องกับคลาสที่มีคลาสด้านในเรียกว่าชั้นนอก
ผู้เริ่มต้นหลายคนจะถามอย่างแน่นอนว่าทำไมชั้นเรียนหนึ่งควรกำหนดในชั้นเรียนอื่น?
บางครั้งมีปัญหาบางอย่างในการเขียนโปรแกรมของเราที่ยากต่อการแก้ปัญหาโดยใช้อินเทอร์เฟซ ในเวลานี้เราสามารถใช้ความสามารถที่จัดทำโดยคลาสภายในเพื่อสืบทอดคลาสคอนกรีตหรือคลาสนามธรรมหลายคลาสเพื่อแก้ปัญหาการเขียนโปรแกรมเหล่านี้ อาจกล่าวได้ว่าอินเทอร์เฟซจะแก้ปัญหาบางอย่างเท่านั้นในขณะที่คลาสภายในทำให้การแก้ปัญหาการสืบทอดหลายครั้งสมบูรณ์ยิ่งขึ้น
มีประโยคใน "Think in Java": เหตุผลที่น่าสนใจที่สุดสำหรับการใช้คลาสภายในคือแต่ละชั้นเรียนภายในสามารถสืบทอดการใช้งาน (อินเตอร์เฟส) ได้อย่างอิสระดังนั้นไม่ว่าคลาสอุปกรณ์ต่อพ่วงจะได้รับการใช้งาน (อินเทอร์เฟซ) อย่างอิสระ
คุณแม่อินเทอร์เฟซสาธารณะ {} แม่อินเทอร์เฟซสาธารณะ {} ลูกชายชั้นเรียนสาธารณะใช้พ่อแม่ {} ลูกสาวชั้นเรียนสาธารณะใช้พ่อ {คลาส mother_ ใช้แม่ {}}}คุณสมบัติชั้นเรียนภายใน
1. คลาสภายในสามารถใช้หลายอินสแตนซ์แต่ละอินสแตนซ์มีข้อมูลสถานะของตนเองและเป็นอิสระจากข้อมูลวัตถุต่อพ่วงอื่น ๆ
2. ในคลาสอุปกรณ์ต่อพ่วงเดียวคลาสภายในหลายชั้นสามารถใช้อินเทอร์เฟซเดียวกันในรูปแบบที่แตกต่างกันหรือสืบทอดคลาสเดียวกัน
3. ช่วงเวลาที่สร้างวัตถุคลาสภายในไม่ได้ขึ้นอยู่กับการสร้างวัตถุคลาสรอบนอก
4. ไม่มีความสัมพันธ์ที่สับสน "IS-A" ในชั้นเรียนภายในมันเป็นนิติบุคคลอิสระ
5. คลาสด้านในให้การห่อหุ้มที่ดีขึ้นและไม่สามารถเข้าถึงคลาสอื่น ๆ ได้ยกเว้นคลาสอุปกรณ์ต่อพ่วง
แพ็คเกจ com.java.test; คลาสสาธารณะ Outerclass {ชื่อสตริงส่วนตัว; อายุ int ส่วนตัว; สตริงสาธารณะ getName () {ชื่อคืน; } โมฆะสาธารณะ setName (ชื่อสตริง) {this.name = name; } public int getage () {return Age; } การตั้งค่าโมฆะสาธารณะ (อายุ int) {this.age = อายุ; } public void display () {system.out.println ("การแสดงผลของ outerclass เรียกว่า"); } คลาสสาธารณะ innerclass {public innerclass () {name = "chenssy"; อายุ = 23; } สาธารณะ outerclass getouterclass () {return outerclass.his; } public void display () {system.out.println ("ชื่อ:" + getName () + "; อายุ:" + getage ()); }} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {outerclass outerclass = new OuterClass (); outerclass.innerClass innerclass = outerclass.new innerclass (); innerclass.display (); innerclass.getouterclass (). display (); }} ชื่อ: Chenssy; อายุ: 23การแสดงผลของ outerclass เรียกว่า
เราจำเป็นต้องชัดเจนว่าชั้นเรียนภายในเป็นแนวคิดการรวบรวมเวลา เมื่อรวบรวมได้สำเร็จพวกเขาจะอยู่ในสองคลาสที่แตกต่างกันอย่างสิ้นเชิงจากชั้นเรียนรอบข้าง (แน่นอนว่าพวกเขายังคงเกี่ยวข้อง)
นอกจากนี้เรายังเห็นวิธีการอ้างอิงคลาสภายใน: อ้างถึงคลาสภายในเราจำเป็นต้องระบุประเภทของวัตถุนี้: OuterClasname.innerClassName ในเวลาเดียวกันถ้าเราต้องการสร้างวัตถุคลาสภายในเราต้องใช้วัตถุคลาสภายนอกเพื่อสร้างคลาสภายในผ่าน. ใหม่: OuterClass.innerClass InnerClass = OUTERCLASS.NEW InnerClass ();
ในเวลาเดียวกันหากเราต้องการสร้างการอ้างอิงไปยังวัตถุคลาสภายนอกเราสามารถใช้ outerclassname นี่เพื่อให้เราสามารถสร้างการอ้างอิงไปยังคลาสภายนอกได้อย่างถูกต้อง
ใน Java คลาสภายในส่วนใหญ่จะแบ่งออกเป็นคลาสสมาชิกภายในคลาสภายในท้องถิ่นคลาสภายในที่ไม่ระบุชื่อและคลาสภายในแบบคงที่
ชั้นเรียนภายใน
คลาสสมาชิกภายในยังเป็นคลาสภายในที่พบมากที่สุด มันเป็นสมาชิกของคลาสอุปกรณ์ต่อพ่วงดังนั้นจึงสามารถเข้าถึงแอตทริบิวต์สมาชิกทั้งหมดและวิธีการของคลาสอุปกรณ์ต่อพ่วงโดยไม่มีข้อ จำกัด แม้ว่าจะเป็นส่วนตัวหากคลาสอุปกรณ์ต่อพ่วงต้องการเข้าถึงแอตทริบิวต์สมาชิกและวิธีการของคลาสภายใน แต่ก็จำเป็นต้องเข้าถึงผ่านอินสแตนซ์คลาสภายใน
ควรให้ความสนใจสองจุดในชั้นเรียนภายในของสมาชิก
ไม่สามารถมีตัวแปรและวิธีการคงที่ใด ๆ ในชั้นเรียนภายในของสมาชิก
คลาสสมาชิกภายในจะถูกแนบกับคลาสอุปกรณ์ต่อพ่วงดังนั้นคลาสภายในสามารถสร้างได้ก็ต่อเมื่อคลาสอุปกรณ์ต่อพ่วงถูกสร้างขึ้นก่อน
ชั้นเรียนสาธารณะ outerclass {สตริงส่วนตัว str; โมฆะสาธารณะ Outerdisplay () {System.out.println ("Outerclass ... "); } คลาสสาธารณะ innerclass {โมฆะสาธารณะ innerDisplay () {// ใช้แอตทริบิวต์ str ในอุปกรณ์ต่อพ่วง str = "chenssy ... "; System.out.println (str); // ใช้วิธี outerdisplay (); }} /*แนะนำให้ใช้ getxxx () เพื่อรับคลาสสมาชิกภายในโดยเฉพาะอย่างยิ่งเมื่อคอนสตรัคเตอร์ของคลาสภายในไม่มีพารามิเตอร์* / สาธารณะ innerclass getinnerclass () {return innerclass ใหม่ (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {outerclass outer = new outerclass (); OUTERCLASS.InnerClass Inner = Outer.getInnerClass (); inner.innerDisplay (); -โดยส่วนตัวแล้วฉันขอแนะนำให้ใช้ getxxx () เพื่อให้ได้คลาสสมาชิกภายในโดยเฉพาะอย่างยิ่งเมื่อตัวสร้างของคลาสภายในนี้ไม่มีพารามิเตอร์
ประโยคชั้นเรียนภายในท้องถิ่น
ชั้นเรียนภายในท้องถิ่นจะซ้อนกันภายในวิธีการและขอบเขต การใช้คลาสนี้เป็นหลักในการใช้และแก้ปัญหาที่ค่อนข้างซับซ้อน ฉันต้องการสร้างชั้นเรียนเพื่อช่วยโซลูชันของเรา ในเวลานั้นฉันไม่ต้องการให้คลาสนี้เป็นสาธารณะดังนั้นเราจึงสามารถสร้างชั้นเรียนภายในท้องถิ่น
ชั้นเรียนภายในท้องถิ่นถูกรวบรวมเหมือนคลาสสมาชิกภายใน พวกเขาสามารถใช้ในวิธีนี้และแอตทริบิวต์เท่านั้น หากพวกเขาไม่ได้อยู่ในวิธีนี้และคุณลักษณะนี้พวกเขาจะไม่ถูกต้อง
กำหนดไว้ในวิธีการ:
ระดับสาธารณะ Parcel5 {ปลายทางการทำลายล้างสาธารณะ (String Str) {คลาส Pdestionation ใช้ Destion {ฉลากสตริงส่วนตัว; pdestion ส่วนตัว (String whereto) {label = whereto; } สตริงสาธารณะ readlabel () {return label; }} ส่งคืน pdestion ใหม่ (str); } โมฆะคงที่สาธารณะหลัก (String [] args) {parcel5 parcel5 = new parcel5 (); destion d = parcel5.destionation ("chenssy"); -กำหนดภายในขอบเขต:
Public Class Parcel6 {Private Void InternalTracking (Boolean B) {ถ้า (B) {คลาส trackingslip {id สตริงส่วนตัว; trackingslip (สตริง s) {id = s; } สตริง getSlip () {return id; }} trackingslip ts = trackingslip ใหม่ ("chenssy"); สตริงสตริง = ts.getSlip (); }} แทร็กโมฆะสาธารณะ () {internalTracking (จริง); } โมฆะคงที่สาธารณะหลัก (String [] args) {parcel6 parcel6 = new parcel6 (); Parcel6.track (); -ชั้นเรียนภายในที่ไม่ระบุชื่อ
คลาสสาธารณะ OuterClass {Public InnerClass getInnerClass (สุดท้าย int num, String str2) {ส่งคืน InnerClass ใหม่ () {หมายเลข int = num + 3; สาธารณะ int getNumber () {หมายเลขคืน; - / * หมายเหตุ: เซมิโคลอนไม่สามารถบันทึก */} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {outerclass out = new outerclass (); innerclass inner = out.getInnerClass (2, "chenssy"); System.out.println (inner.getNumber ()); }} อินเตอร์เฟส innerclass {int getNumber ();}1. คลาสภายในที่ไม่ระบุชื่อไม่มีตัวดัดแปลงการเข้าถึง
2. คลาสภายในที่ไม่ระบุชื่อใหม่คลาสนี้จะต้องมีอยู่ก่อน หากเราแสดงความคิดเห็นว่าอินเทอร์เฟซ InnerClass ข้อผิดพลาดในการรวบรวมจะเกิดขึ้น
3. ให้ความสนใจกับพารามิเตอร์อย่างเป็นทางการของวิธี getinnerclass () พารามิเตอร์ที่เป็นทางการครั้งแรกได้รับการแก้ไขด้วยขั้นสุดท้ายในขณะที่พารามิเตอร์ที่สองไม่ได้ ในเวลาเดียวกันเรายังพบว่าพารามิเตอร์ที่เป็นทางการที่สองไม่ได้ถูกใช้ในคลาสภายในที่ไม่ระบุชื่อดังนั้นเมื่อพารามิเตอร์ที่เป็นทางการของวิธีการจะต้องใช้โดยคลาสภายในที่ไม่ระบุชื่อแล้วพารามิเตอร์ที่เป็นทางการนี้จะต้องเป็นที่สิ้นสุด
4. ไม่มีตัวสร้างสำหรับชั้นเรียนภายในที่ไม่ระบุชื่อ เพราะมันไม่มีชื่อที่จะสร้างมัน
ชั้นในแบบคงที่
Static สามารถปรับเปลี่ยนตัวแปรสมาชิกวิธีการบล็อกรหัสและคลาสภายในอื่น ๆ เราเรียกคลาสชั้นในที่แก้ไขด้วยสแตติกแบบคงที่ แต่เราต้องการเรียกพวกเขาว่าคลาสซ้อนกันภายใน ความแตกต่างที่ใหญ่ที่สุดระหว่างคลาสภายในแบบคงที่และชั้นเรียนภายในที่ไม่คงที่คือหลังจากการรวบรวมเสร็จสิ้นการอ้างอิงจะถูกซ่อนไว้และการใช้จะชี้ไปที่รอบนอก แต่คลาสภายในแบบคงที่ไม่ได้ซึ่งหมายความว่าการสร้างชั้นเรียนภายในแบบคงที่ไม่จำเป็นต้องพึ่งพาคลาสอุปกรณ์ต่อพ่วงและไม่สามารถใช้ตัวแปรสมาชิกที่ไม่ใช่สมาชิกและวิธีการของคลาสอุปกรณ์ต่อพ่วงใด ๆ
ชั้นเรียนสาธารณะ outerclass {เซ็กซ์สตริงส่วนตัว; ชื่อสตริงคงที่สาธารณะ = "Chenssy"; / ***คลาสภายในแบบคงที่*/ คลาสคงที่ innerClass1 {/*สมาชิกคงที่สามารถมีอยู่ในคลาสภายในแบบคงที่*/ สตริงคงที่สาธารณะ _name1 = "chenssy_static"; การแสดงโมฆะสาธารณะ () { /** คลาสภายในแบบคงที่สามารถเข้าถึงตัวแปรสมาชิกคงที่และวิธีการของคลาสอุปกรณ์ต่อพ่วง* ไม่สามารถเข้าถึงตัวแปรสมาชิกที่ไม่ใช่สมาชิกและวิธีการของคลาสอุปกรณ์ต่อพ่วง* / system.out.println ("ชื่อ Outclass:" + ชื่อ); }} / *** คลาสภายในที่ไม่คงที่* / คลาส innerClass2 { /* สมาชิกคงที่ไม่สามารถมีอยู่ในคลาสภายในที่ไม่คงที่* / สตริงสาธารณะ _name2 = "chenssy_inner"; / * สมาชิกใด ๆ ของคลาสอุปกรณ์ต่อพ่วงสามารถเรียกได้ในคลาสที่ไม่คงที่ภายในไม่ว่าจะเป็นแบบคงที่หรือไม่คงที่ */ โมฆะสาธารณะ () {System.out.println ("ชื่อ outerclass:" + ชื่อ); }} /** * @DESC MEBERAL CLASS วิธี * @Author Chenssy * @Data 2013-10-25 * @return เป็นโมฆะ * /Public Void Display () { / * คลาสอุปกรณ์เข้าถึงคลาสภายในแบบคงที่: ชั้นใน */ system.out.println (innerclass1._name1); /* คลาสภายในแบบคงที่สามารถสร้างได้โดยตรงโดยไม่ต้องพึ่งพาคลาสอุปกรณ์ต่อพ่วง*/ ใหม่ innerClass1 (). display (); /* การสร้างภายในที่ไม่คงที่จำเป็นต้องพึ่งพาคลาสอุปกรณ์ต่อพ่วง*/ outerclass.innerclass2 inner2 = new OuterClass () ใหม่ innerClass2 (); /* สมาชิกของชั้นเรียนที่ไม่คงที่จำเป็นต้องใช้อินสแตนซ์ของชั้นเรียนที่ไม่คงที่*/ system.out.println (inner2._name2); inner2.display (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {outerclass outer = new outerclass (); OUTER.DISPLAY (); -สรุป
ข้างต้นเป็นบทสรุปของคุณสมบัติ Java ที่สำคัญทั้งสาม - ความรู้ที่ห่อหุ้มซึ่งบรรณาธิการแนะนำให้คุณรู้จัก ฉันหวังว่ามันจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉันและบรรณาธิการจะตอบกลับคุณทันเวลา ขอบคุณมากสำหรับการสนับสนุนเว็บไซต์ Wulin.com!