ภาษา Java มีตัวดัดแปลงมากมายส่วนใหญ่แบ่งออกเป็นสองประเภทต่อไปนี้:
ตัวดัดแปลงใช้เพื่อกำหนดคลาสวิธีการหรือตัวแปรและมักจะวางไว้ที่ส่วนหน้าของคำสั่ง ลองใช้ตัวอย่างต่อไปนี้เพื่อแสดง:
คลาสคลาสคลาสคลาสชื่อ {// ... } บูลีนส่วนตัว myflag; คงที่สองสัปดาห์สุดท้าย = 9.5; ได้รับการป้องกัน int สุดท้าย int boxwidth = 42; โมฆะคงที่สาธารณะหลัก (สตริง [] อาร์กิวเมนต์) {// วิธีการ}ตัวดัดแปลงการควบคุมการเข้าถึง
ใน Java การควบคุมการเข้าถึงสามารถใช้เพื่อป้องกันการเข้าถึงคลาสตัวแปรวิธีการและตัวสร้าง Java รองรับการเข้าถึง 4 สิทธิ์ที่แตกต่างกัน
ค่าเริ่มต้นหรือที่เรียกว่าค่าเริ่มต้นสามารถมองเห็นได้ภายในแพ็คเกจเดียวกันโดยไม่ต้องใช้ตัวดัดแปลงใด ๆ
ส่วนตัวระบุด้วยตัวดัดแปลงส่วนตัวซึ่งมองเห็นได้ภายในชั้นเรียนเดียวกัน
สามัญระบุโดยตัวดัดแปลงสาธารณะซึ่งมองเห็นได้ทุกชั้น
ได้รับการป้องกันระบุด้วยตัวดัดแปลงที่ได้รับการป้องกันซึ่งมองเห็นได้จากคลาสและคลาสย่อยทั้งหมดภายในแพ็คเกจเดียวกัน
ตัวปรับเปลี่ยนการเข้าถึงเริ่มต้น - ไม่มีการใช้คำหลัก
ตัวแปรและวิธีการที่ประกาศโดยตัวดัดแปลงการเข้าถึงเริ่มต้นสามารถมองเห็นคลาสภายในแพ็คเกจเดียวกัน ตัวแปรทั้งหมดในอินเทอร์เฟซได้รับการประกาศโดยปริยายว่าเป็นแบบคงที่สาธารณะสุดท้ายในขณะที่วิธีการในอินเทอร์เฟซเป็นสาธารณะโดยค่าเริ่มต้น
ตัวอย่าง:
ดังที่แสดงในตัวอย่างต่อไปนี้การประกาศตัวแปรและวิธีการสามารถทำได้โดยไม่ต้องมีตัวดัดแปลงใด ๆ
String version = "1.5.1"; Boolean ProcessOrder () {return true;}Private Access Modifier - ส่วนตัว
ตัวดัดแปลงการเข้าถึงส่วนตัวเป็นระดับการเข้าถึงที่เข้มงวดที่สุดดังนั้นวิธีการตัวแปรและตัวสร้างที่ประกาศว่าเป็นส่วนตัวสามารถเข้าถึงได้โดยชั้นเรียนที่พวกเขาอยู่และคลาสและอินเทอร์เฟซไม่สามารถประกาศเป็นส่วนตัวได้
ตัวแปรที่ประกาศว่าเป็นประเภทการเข้าถึงส่วนตัวสามารถเข้าถึงได้โดยคลาสภายนอกผ่านวิธีการ getter สาธารณะในชั้นเรียน
การใช้ตัวดัดแปลงการเข้าถึงส่วนตัวส่วนใหญ่จะใช้เพื่อซ่อนรายละเอียดการใช้งานของชั้นเรียนและปกป้องข้อมูลของชั้นเรียน
คลาสต่อไปนี้ใช้ตัวดัดแปลงการเข้าถึงส่วนตัว:
Logger คลาสสาธารณะ {รูปแบบสตริงส่วนตัว; สตริงสาธารณะ getFormat () {return this.format; } โมฆะสาธารณะ setFormat (รูปแบบสตริง) {this.format = รูปแบบ; -ในตัวอย่างตัวแปรรูปแบบในคลาส Logger เป็นตัวแปรส่วนตัวดังนั้นคลาสอื่น ๆ จึงไม่สามารถรับและตั้งค่าของตัวแปรได้โดยตรง ในการเปิดใช้งานคลาสอื่น ๆ เพื่อจัดการกับตัวแปรได้มีการกำหนดวิธีการสาธารณะสองวิธี: getFormat () (ส่งคืนค่าของรูปแบบ) และ setFormat (สตริง) (ตั้งค่าของรูปแบบ)
Public Access Modifier - สาธารณะ
คลาสวิธีการสร้างและอินเทอร์เฟซที่ประกาศว่าเป็นสาธารณะสามารถเข้าถึงได้โดยคลาสอื่น ๆ
หากคลาสสาธารณะหลายแห่งที่เข้าถึงซึ่งกันและกันมีการแจกจ่ายในแพ็คเกจที่แตกต่างกันคุณจะต้องนำเข้าแพ็คเกจที่ระดับสาธารณะที่สอดคล้องกันอยู่ เนื่องจากการสืบทอดของชั้นเรียนวิธีการสาธารณะและตัวแปรทั้งหมดของคลาสสามารถสืบทอดได้โดยคลาสย่อย
ฟังก์ชั่นต่อไปนี้ใช้การควบคุมการเข้าถึงสาธารณะ:
โมฆะคงที่สาธารณะหลัก (String [] อาร์กิวเมนต์) {// ... }วิธีการหลัก () ของโปรแกรม Java จะต้องตั้งค่าเป็นสาธารณะมิฉะนั้นล่าม Java จะไม่สามารถเรียกใช้คลาสได้
ตัวดัดแปลงการเข้าถึงที่ได้รับการป้องกัน - ป้องกัน
ตัวแปรวิธีการและตัวสร้างที่ประกาศว่าสามารถเข้าถึงได้โดยคลาสอื่น ๆ ในแพ็คเกจเดียวกันหรือโดยคลาสย่อยในแพ็คเกจที่แตกต่างกัน
ตัวดัดแปลงการเข้าถึงที่ได้รับการป้องกันไม่สามารถแก้ไขคลาสและอินเทอร์เฟซ วิธีการและตัวแปรสมาชิกสามารถประกาศได้ว่าเป็นการป้องกัน แต่ตัวแปรสมาชิกและวิธีการสมาชิกของอินเตอร์เฟสไม่สามารถประกาศได้ว่าได้รับการป้องกัน
คลาสย่อยสามารถเข้าถึงวิธีการและตัวแปรที่ประกาศโดยตัวดัดแปลงที่ได้รับการป้องกันเพื่อให้สามารถปกป้องคลาสที่ไม่เกี่ยวข้องจากการใช้วิธีการและตัวแปรเหล่านี้
คลาสพาเรนต์ต่อไปนี้ใช้ตัวดัดแปลงการเข้าถึงที่ได้รับการป้องกันและคลาสย่อยโอเวอร์โหลดเมธอด OpenSpeaker () ของคลาสแม่
คลาส AudioPlayer {Protected Boolean OpenSpeaker (Speaker SP) {// รายละเอียดการใช้งาน}} คลาสสตรีมมิ่งผู้เล่น {บูลีน openspeaker (ลำโพง sp) {// รายละเอียดการใช้งาน}}}}}}}}}}}หากวิธีการ OpenSpeaker () ถูกประกาศว่าเป็นส่วนตัวคลาสอื่นที่ไม่ใช่เครื่องเสียงจะไม่สามารถเข้าถึงวิธีการได้ หาก OpenSpeaker () ถูกประกาศสาธารณะคลาสทั้งหมดสามารถเข้าถึงวิธีการ หากเราต้องการให้วิธีการที่จะมองเห็นได้เฉพาะคลาสย่อยของคลาสที่อยู่ในนั้นให้ประกาศวิธีการที่ได้รับการปกป้อง
การควบคุมการเข้าถึงและการสืบทอด
โปรดทราบกฎการสืบทอดต่อไปนี้:
ตัวดัดแปลงที่ไม่เข้าถึง
เพื่อใช้งานฟังก์ชั่นอื่น ๆ Java ยังมีตัวดัดแปลงที่ไม่ใช่การเข้าถึงจำนวนมาก
ตัวดัดแปลงแบบคงที่ใช้ในการสร้างวิธีการคลาสและตัวแปรคลาส
ตัวดัดแปลงสุดท้ายใช้ในการปรับเปลี่ยนคลาสวิธีการและตัวแปร คลาสที่แก้ไขโดยขั้นสุดท้ายไม่สามารถสืบทอดได้วิธีการแก้ไขไม่สามารถนิยามใหม่โดยคลาสที่สืบทอดมาและตัวแปรที่แก้ไขเป็นค่าคงที่และไม่สามารถแก้ไขได้
ตัวดัดแปลงบทคัดย่อใช้ในการสร้างคลาสนามธรรมและวิธีการนามธรรม
ตัวดัดแปลงแบบซิงโครไนซ์และผันผวนส่วนใหญ่จะใช้สำหรับการเขียนโปรแกรมเธรด
ตัวดัดแปลงคงที่
คำหลักคงที่ใช้เพื่อประกาศตัวแปรคงที่เป็นอิสระจากวัตถุ ไม่ว่าจะมีวัตถุกี่ชิ้นในชั้นเรียนอินสแตนติสมันมีเพียงหนึ่งสำเนาของตัวแปรคงที่ ตัวแปรคงที่เรียกว่าตัวแปรคลาส ตัวแปรท้องถิ่นสามารถประกาศเป็นตัวแปรคงที่
คำหลักคงที่ใช้เพื่อประกาศวิธีการคงที่โดยไม่ขึ้นกับวัตถุ วิธีการคงที่ไม่สามารถใช้ตัวแปรที่ไม่คงที่ของคลาส วิธีการคงที่ได้รับข้อมูลจากรายการพารามิเตอร์จากนั้นคำนวณข้อมูล
การเข้าถึงตัวแปรคลาสและวิธีการสามารถเข้าถึงได้โดยตรงโดยใช้ className.Variablename และ className.methodname
ดังที่แสดงในตัวอย่างต่อไปนี้ตัวดัดแปลงแบบคงที่จะใช้เพื่อสร้างวิธีการคลาสและตัวแปรคลาส
คลาสสาธารณะ instancecounter {ส่วนตัวคงที่ int numinstances = 0; ได้รับการป้องกัน int int getCount () {return numinstances; } โมฆะคงที่ส่วนตัว addInstance () {numinstances ++; } Instancecounter () {Instancecounter.addinstance (); } โมฆะคงที่สาธารณะหลัก (สตริง [] อาร์กิวเมนต์) {System.out.println ("เริ่มต้นด้วย" + instancecounter.getCount () + "อินสแตนซ์"); สำหรับ (int i = 0; i <500; ++ i) {new Instancecounter (); } system.out.println ("สร้าง" + instancecounter.getCount () + "อินสแตนซ์"); -ตัวอย่างข้างต้นมีการเรียกใช้และแก้ไขดังนี้:
เริ่มต้นด้วย 0 อินสแตนซ์
สร้าง 500 อินสแตนซ์
ตัวดัดแปลงสุดท้าย
ตัวแปรสุดท้าย:
ตัวแปรสุดท้ายสามารถเริ่มต้นได้อย่างชัดเจนและสามารถเริ่มต้นได้เพียงครั้งเดียว การอ้างอิงถึงวัตถุที่ประกาศว่าเป็นขั้นสุดท้ายไม่สามารถชี้ไปที่วัตถุต่าง ๆ ได้ แต่ข้อมูลในวัตถุสุดท้ายสามารถเปลี่ยนแปลงได้ กล่าวอีกนัยหนึ่งการอ้างอิงถึงวัตถุสุดท้ายไม่สามารถเปลี่ยนแปลงได้ แต่ค่าภายในสามารถเปลี่ยนแปลงได้
ตัวดัดแปลงสุดท้ายมักจะใช้ร่วมกับตัวดัดแปลงแบบคงที่เพื่อสร้างค่าคงที่ของชั้นเรียน
ตัวอย่าง:
การทดสอบระดับสาธารณะ {ค่า int สุดท้าย = 10; // ด้านล่างเป็นตัวอย่างที่ประกาศว่า int สุดท้ายคงที่สาธารณะคงที่ boxwidth = 6; String สุดท้าย String title = "Manager"; โมฆะสาธารณะ changevalue () {value = 12; // ข้อผิดพลาดจะถูกส่งออก}}วิธีสุดท้าย
วิธีสุดท้ายในคลาสสามารถสืบทอดได้โดยคลาสย่อย แต่ไม่สามารถแก้ไขได้โดยคลาสย่อย
วัตถุประสงค์หลักของการประกาศวิธีสุดท้ายคือการป้องกันไม่ให้เนื้อหาของวิธีการถูกแก้ไข
ดังที่แสดงไว้ด้านล่างประกาศวิธีการโดยใช้ตัวดัดแปลงสุดท้าย
การทดสอบระดับสาธารณะ {public void void changename () {// method body}}}ชั้นสุดท้าย
ชั้นเรียนสุดท้ายไม่สามารถสืบทอดได้และไม่มีชั้นเรียนใดสามารถสืบทอดคุณสมบัติใด ๆ ของคลาสสุดท้ายได้
ตัวอย่าง:
การทดสอบระดับสุดท้ายของสาธารณะ {// class body}ตัวดัดแปลงบทคัดย่อ
คลาสบทคัดย่อ:
คลาสนามธรรมไม่สามารถใช้ในการสร้างอินสแตนซ์วัตถุ จุดประสงค์เดียวของการประกาศคลาสนามธรรมคือการขยายชั้นเรียนในอนาคต
คลาสไม่สามารถแก้ไขได้โดยนามธรรมและสุดท้ายในเวลาเดียวกัน หากคลาสมีวิธีการนามธรรมคลาสจะต้องประกาศว่าเป็นคลาสนามธรรมมิฉะนั้นจะมีข้อผิดพลาดในการรวบรวม
คลาสบทคัดย่อสามารถมีวิธีการนามธรรมและวิธีการที่ไม่ได้รับการรับรอง
ตัวอย่าง:
คาราวานคลาสนามธรรม {ราคาสองเท่าส่วนตัว; รุ่นสตริงส่วนตัว; สตริงส่วนตัว บทคัดย่อสาธารณะเป็นโมฆะ Gofast (); // บทคัดย่อวิธีการสาธารณะเป็นนามธรรม Void Changecolor ();}วิธีนามธรรม
วิธีนามธรรมเป็นวิธีการที่ไม่มีการใช้งานใด ๆ และการใช้งานเฉพาะของวิธีการจัดทำโดยคลาสย่อย วิธีการนามธรรมไม่สามารถประกาศได้ว่าเป็นขั้นสุดท้ายและเข้มงวด
คลาสย่อยใด ๆ ที่สืบทอดคลาสนามธรรมจะต้องใช้วิธีการนามธรรมทั้งหมดของคลาสแม่เว้นแต่ว่าคลาสย่อยจะเป็นคลาสนามธรรม
หากคลาสมีวิธีการนามธรรมหลายวิธีคลาสจะต้องประกาศว่าเป็นคลาสนามธรรม คลาสบทคัดย่ออาจไม่มีวิธีนามธรรม
การประกาศของวิธีนามธรรมลงท้ายด้วยเครื่องหมายอัฒภาคตัวอย่างเช่นตัวอย่างนามธรรมสาธารณะ ();
ตัวอย่าง:
Superclass คลาสนามธรรมสาธารณะ {Abstract Void M (); // Abstract Method} คลาส subclass ขยาย superclass {// ใช้วิธีนามธรรมวิธีการโมฆะ m () {......... }}ตัวดัดแปลงแบบซิงโครไนซ์
วิธีที่ประกาศโดยคำหลักที่ซิงโครไนซ์สามารถเข้าถึงได้โดยหนึ่งเธรดในเวลาเดียวกัน ตัวดัดแปลงแบบซิงโครไนซ์สามารถนำไปใช้กับตัวดัดแปลงการเข้าถึงสี่ตัว
ตัวอย่าง:
Public Synchronized Void ShowDetails () {...... }ตัวดัดแปลงชั่วคราว
เมื่อวัตถุที่เป็นอนุกรมมีตัวแปรอินสแตนซ์ที่ปรับเปลี่ยนชั่วคราวเครื่องเสมือน Java (JVM) จะข้ามตัวแปรเฉพาะนั้น
ตัวดัดแปลงนี้รวมอยู่ในคำสั่งที่กำหนดตัวแปรและใช้เพื่อประมวลผลประเภทข้อมูลของคลาสและตัวแปรล่วงหน้า
ตัวอย่าง:
ขีด จำกัด int ชั่วคราวสาธารณะ = 55; // จะไม่คงอยู่ในที่สาธารณะ in b; // จะคงอยู่
ตัวดัดแปลงผันผวน
ตัวแปรสมาชิกที่ปรับเปลี่ยนได้จะถูกบังคับให้อ่านค่าตัวแปรสมาชิกจากหน่วยความจำที่ใช้ร่วมกันในแต่ละครั้งที่มีการเข้าถึงโดยเธรด ยิ่งไปกว่านั้นเมื่อตัวแปรสมาชิกเปลี่ยนแปลงเธรดจะถูกบังคับให้เขียนค่าการเปลี่ยนแปลงกลับไปที่หน่วยความจำที่ใช้ร่วมกัน ด้วยวิธีนี้เมื่อใดก็ตามที่สองเธรดที่แตกต่างกันจะเห็นค่าเดียวกันของตัวแปรสมาชิกบางตัวเสมอ การอ้างอิงวัตถุที่ผันผวนอาจเป็นโมฆะ
ตัวอย่าง:
ชั้นเรียนสาธารณะ Myrunnable ใช้งานได้ {บูลีนผันผวนส่วนตัวที่ใช้งานอยู่; โมฆะสาธารณะเรียกใช้ () {active = true; ในขณะที่ (active) // line 1 {// code}} โมฆะสาธารณะหยุด () {active = false; // บรรทัด 2}}โดยทั่วไปวิธีการเรียกใช้ () เรียกว่าในเธรดหนึ่งและวิธีการหยุด () เรียกว่าในเธรดอื่น หากใช้ค่าใน Line 1 ที่ใช้งานอยู่ในบัฟเฟอร์ลูปจะไม่หยุดเมื่อใช้งานในบรรทัด 2 ถูกตั้งค่าเป็นเท็จ
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่าเนื้อหาของบทความนี้จะช่วยในการศึกษาหรือทำงานของทุกคน ฉันหวังว่าจะสนับสนุน Wulin.com เพิ่มเติม!