ใน Java ทุกอย่างมีรูปแบบการควบคุมการเข้าถึง
ระดับการควบคุมของการอนุญาตการเข้าถึงมาจากที่ใหญ่ที่สุดถึงขั้นต่ำ: สาธารณะ, ได้รับการป้องกัน, แพคเกจการเข้าถึงสิทธิ์ (ไม่มีคำหลัก) และส่วนตัว
เมื่อใช้งานตัวดัดแปลง Java Access, สาธารณะ, ได้รับการปกป้องและส่วนตัวจะถูกวางไว้ก่อนคำจำกัดความของสมาชิกแต่ละคน (โดเมนหรือวิธีการ) ในชั้นเรียน
1. สิทธิ์การเข้าถึงของสมาชิกชั้นเรียน
วิธีเดียวที่จะได้รับการเข้าถึงสมาชิกคือ:
1). ทำให้สมาชิกคนนี้เป็นสาธารณะ ไม่ว่าใครจะเป็นสมาชิกสามารถเข้าถึงได้;
2). ให้การเข้าถึงแพ็คเก็ตให้สมาชิกโดยตัวดัดแปลงที่ไม่ได้รับการแก้ไขและวางคลาสอื่น ๆ ในแพ็คเกจเดียวกันและคลาสอื่น ๆ ในแพ็คเกจสามารถเข้าถึงสมาชิกได้
3). ชั้นเรียนที่สืบทอดมาสามารถเข้าถึงทั้งสมาชิกสาธารณะและสมาชิกที่ได้รับการคุ้มครอง
4). จัดเตรียมวิธี accessor และ mutator เพื่ออ่านและเปลี่ยนค่าตัวเลข
1. สิทธิ์การเข้าถึงแพ็คเกจ
สิทธิ์การเข้าถึงเริ่มต้นไม่มีคำหลักใด ๆ แต่ผ่านหมายถึงการอนุญาตการเข้าถึงแพ็คเกจซึ่งหมายความว่าคลาสอื่น ๆ ทั้งหมดในรายงานปัจจุบันสามารถเข้าถึงสมาชิกนั้นได้ แต่สำหรับทุกคลาสนอกแพ็คเกจนี้สมาชิกนี้เป็นส่วนตัว
การเข้าถึงแพ็คเกจรวมคลาสที่เกี่ยวข้องทั้งหมดไว้ในแพ็คเกจเพื่อให้สามารถโต้ตอบกันได้อย่างง่ายดาย
หมายเหตุ: หากทั้งสองคลาสอยู่ในไดเรกทอรีเดียวกันและไม่ได้ตั้งชื่อแพ็คเกจใด ๆ สำหรับตัวเอง Java จะพิจารณาไฟล์ดังกล่าวโดยอัตโนมัติว่าเป็นแพ็คเกจเริ่มต้นที่เกี่ยวข้องกับไดเรกทอรีดังนั้นไฟล์เหล่านี้จึงมีการเข้าถึงแพ็คเกจซึ่งกันและกัน
ตัวอย่างต่อไปนี้แสดงปัญหานี้:
// เค้กคลาสและพายอยู่ในไดเรกทอรีเดียวกันและไม่แสดงอย่างชัดเจนในพายคลาสแพ็คเกจใด ๆ {void f () {system.out.println ("pie.f ()"); }} เค้กคลาส {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {พาย x = ใหม่พาย (); xf (); }} // เอาต์พุตคือ pie.f ()2.Public: สิทธิ์การเข้าถึงส่วนต่อประสาน
การใช้คำหลักสาธารณะหมายความว่าการประกาศสมาชิกที่ตามมามีให้สำหรับทุกคนโดยเฉพาะโปรแกรมเมอร์ลูกค้าที่ใช้ไลบรารีคลาส
3. เอกชน: คุณไม่สามารถเข้าถึงได้
คำหลักส่วนตัวระบุว่าไม่มีคลาสอื่นนอกเหนือจากคลาสที่มีสมาชิกไม่สามารถเข้าถึงสมาชิกได้ คลาสอื่น ๆ ในแพ็คเกจเดียวกันไม่สามารถเข้าถึงสมาชิกส่วนตัวของชั้นเรียนนี้ได้ดังนั้นนี่จึงเทียบเท่ากับการแยกตัวเอง
ฟังก์ชั่นของคำหลักส่วนตัวนี้มีการใช้งานมากมายเช่นการควบคุมวิธีการสร้างวัตถุและป้องกันไม่ให้ผู้อื่นเข้าถึงตัวสร้างที่เฉพาะเจาะจงโดยตรง (หรือตัวสร้างทั้งหมด) ดู
ตัวอย่างต่อไปนี้:
Sundae ชั้นเรียน {private sundae () {} sundae คงที่ makeasundae () {ส่งคืน sundae ใหม่ (); }} คลาสสาธารณะ Icecream {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {sundae x = sundae.makeasundae (); -ในตัวอย่างนี้เราสามารถสร้างวัตถุ sundae ได้โดยเรียกวิธี MakeAsundae () แต่เราไม่สามารถสร้างผ่านตัวสร้างได้
นอกจากนี้ยังใช้กับเขตข้อมูลส่วนตัวในชั้นเรียน
อย่างไรก็ตามสิ่งหนึ่งที่ควรทราบคือคุณไม่สามารถคิดได้ว่าวัตถุอื่น ๆ ไม่สามารถมีการอ้างอิงสาธารณะกับวัตถุเพียงเพราะการอ้างอิงถึงวัตถุในชั้นเรียนเป็นส่วนตัว
4. ได้รับการปกป้อง: มรดกการเข้าถึงสิทธิ์
หากแพ็คเกจใหม่ถูกสร้างขึ้นและสืบทอดคลาสจากแพ็คเกจอื่นสมาชิกเท่านั้นที่สามารถเข้าถึงได้คือสมาชิกสาธารณะของแพ็คเกจต้นทาง
บางครั้งผู้สร้างคลาสฐานต้องการกำหนดการเข้าถึงสมาชิกเฉพาะให้กับคลาสที่ได้รับมากกว่าคลาสทั้งหมดซึ่งต้องใช้คำหลักที่ได้รับการปกป้อง
โปรดทราบว่าการป้องกันยังให้การเข้าถึงแพ็คเกจนั่นคือคลาสอื่น ๆ ภายในแพ็คเกจเดียวกันยังสามารถเข้าถึงองค์ประกอบที่ได้รับการป้องกันของคลาสนี้
2. อินเทอร์เฟซและการใช้งาน
การควบคุมสิทธิ์การเข้าถึงมักถูกเรียกว่าซ่อนอยู่ในการใช้งานที่เป็นรูปธรรม
ข้อมูลบรรจุภัณฑ์และวิธีการในชั้นเรียนและการซ่อนการใช้งานเฉพาะมักเรียกว่าการห่อหุ้ม
ด้วยเหตุผลสองประการที่สำคัญการควบคุมการอนุญาตการเข้าถึงจะอยู่ขอบเขตของการอนุญาตภายในประเภทข้อมูล:
1. ตั้งค่าขีด จำกัด ที่โปรแกรมเมอร์ไคลเอนต์สามารถใช้และไม่สามารถใช้งานได้ คุณสามารถสร้างกลไกภายในของคุณเองในโครงสร้างโดยไม่ต้องกังวลว่าโปรแกรมเมอร์ลูกค้าจะปฏิบัติต่อกลไกภายในโดยไม่ตั้งใจซึ่งเป็นส่วนหนึ่งของอินเทอร์เฟซที่ใช้
2. แยกอินเทอร์เฟซและการใช้งานเฉพาะ
3. การอนุญาตการเข้าถึงชั้นเรียน
ใน Java ตัวดัดแปลงการเข้าถึงยังสามารถใช้เพื่อกำหนดคลาสในไลบรารีที่ผู้ใช้ของไลบรารีพร้อมใช้งาน
ตัวดัดแปลงจะต้องวางไว้ก่อนคลาสคำหลัก ตัวอย่างเช่น:
วิดเจ็ตชั้นเรียนสาธารณะ {...... } หรือ
ปรับปรุงการเข้าถึง widget;
คุณควรรู้ว่าชั้นเรียนไม่สามารถเป็นส่วนตัวได้ (หากชั้นเรียนเป็นส่วนตัวไม่สามารถเข้าถึงคลาสอื่นได้ยกเว้นชั้นเรียน) และไม่สามารถได้รับการปกป้อง (อันที่จริงคลาสภายในสามารถเป็นส่วนตัวหรือได้รับการปกป้อง แต่นี่เป็นกรณีพิเศษตามที่อธิบายไว้ในบทความที่ตามมา)
หากคุณไม่ต้องการให้ผู้อื่นเข้าถึงคลาสคุณสามารถระบุตัวสร้างทั้งหมดของคลาสเป็นส่วนตัวป้องกันไม่ให้ใครสร้างวัตถุในชั้นเรียน แต่มีข้อยกเว้นสำหรับสิ่งนี้ซึ่งไม่สามารถป้องกันไม่ให้คุณสร้างชั้นเรียนภายในสมาชิกคงที่ของชั้นเรียน ดูตัวอย่างต่อไปนี้:
Class Soup1 {Private Soup1 () {} สาธารณะคงที่ soup1 makeoup () {// สร้างวัตถุโดยใช้วิธีคงที่ส่งคืนซุปใหม่ () ใหม่ (); }} คลาสซุป 2 {ซุปส่วนตัว 2 () {} ซุปสแตติกส่วนตัว PS1 = ใหม่ซุป 2 (); // สร้างวัตถุโดยใช้โหมด Singleton Public Public Static Soup2 Access () {return ps1; } โมฆะสาธารณะ f () {}} อาหารกลางวันชั้นเรียนสาธารณะ {void testPrivate () {// ซุปซุป = ซุปใหม่ 1; ไม่สามารถดำเนินการ} void testsingleton () {soup2.access (). f (); -เราจะเห็นได้ว่าตัวสร้างของซุป 1 และซุป 2 เป็นทั้งส่วนตัวและไม่มีใครสามารถใช้ตัวสร้างโดยตรงเพื่อสร้างวัตถุในชั้นนี้ แต่เรายังสามารถใช้สองคลาสนี้: สร้างวิธีการคงที่ในซุป 1 ใช้ตัวสร้างเพื่อสร้างวัตถุซุป 1 และส่งคืนข้อมูลอ้างอิง การสร้าง Soup2 ใช้รูปแบบ Singleton ในรูปแบบการออกแบบและสามารถสร้างวัตถุใดชิ้นหนึ่งเท่านั้น วัตถุประสงค์ของคลาส Soup2 ถูกสร้างขึ้นเป็นสมาชิกส่วนตัวแบบคงที่ของ Soup2 ดังนั้นจึงมีเพียงหนึ่งเดียวและไม่สามารถเข้าถึงได้เว้นแต่จะเข้าถึงได้ผ่านวิธีการสาธารณะ
นอกจากนี้ข้อ จำกัด บางประการมีค่าสังเกต:
1. แต่ละหน่วยการรวบรวมสามารถมีชั้นเรียนสาธารณะเดียวเท่านั้น
2. ชื่อของคลาสสาธารณะจะต้องตรงกับชื่อไฟล์ที่มีหน่วยการรวบรวมรวมถึงตัวพิมพ์ใหญ่บนและล่าง
3. หากไม่มีคลาสสาธารณะในหน่วยรวบรวมคุณสามารถตั้งชื่อไฟล์ได้ตามต้องการ
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น