บทความนี้ส่วนใหญ่ศึกษาคลาสมัลติเพล็กซ์ในการเขียนโปรแกรม Java แล้วคลาสมัลติเพล็กซ์คืออะไรและการใช้งานคืออะไร? นี่คือการแนะนำรายละเอียด
หลังจากอ่านบทสัมภาษณ์กับ Luo Luo Shengyang ฉันอดไม่ได้ที่จะชื่นชมเขา เขายังเด็กมาก ฉันคิดว่าฉันอายุเท่ากันกับ Luo Yonghao และฉันได้พบกับคนใหญ่คนหนึ่งที่ไม่ใช่รายการมัธยมต้นและมัธยมศึกษาตอนปลาย หลังจากการสัมภาษณ์ฉันพบว่า Luo Luo เป็นคนที่ก้าวไปทีละขั้นตอน อย่าบอกว่ามันยากที่จะทำหรือไม่สามารถทำได้ คุณไม่ได้ลองหรือคงอยู่
ถ้าคุณบินไม่ได้แล้ววิ่งถ้าคุณวิ่งไม่ได้แล้วเดินถ้าคุณเดินไม่ได้แล้วคลาน แต่
ไม่ว่าคุณจะทำอะไรคุณต้องก้าวไปข้างหน้า-มาร์ตินลูเทอร์คิง
ชื่อของชั้นเรียนนำกลับมาใช้ใหม่นั้นยากที่จะเข้าใจในตอนแรก ต่อมาฉันไปอ่านหนังสือฉบับภาษาอังกฤษต้นฉบับ ในความเป็นจริงชื่อเรื่องคือการนำชั้นเรียนกลับมาใช้ใหม่และการใช้คลาสที่นำกลับมาใช้ใหม่หมายถึง "การใช้สิ่งที่ทำสำเร็จแล้ว" ในความเป็นจริงวิธีการดำเนินการทั้งสองมักจะได้ยินในการรวมกันของ Java - การรวมกันและการสืบทอด
(1) การรวมกัน
บทบาทของ HAS-A
ทีวีคลาสสาธารณะ {แสดงโชว์; Public String ToString () {return "showgirl"; }} คลาสแสดง {} มาพูดถึงวิธีการ ToString เมื่อคุณต้องการสตริงและคุณเป็นวัตถุคอมไพเลอร์จะเรียกวิธีการ toString ของวัตถุ
มีรายการในทีวี รายการปัจจุบันไม่ได้เริ่มต้นและเป็นโมฆะ วิธีการแสดงไม่สามารถเรียกได้
การรวมกันมีเอฟเฟกต์ที่ทรงพลัง จากมุมมองเชิงวัตถุหากคุณกำลังสร้างคลาสรถคุณสามารถรวมแก้วแสงเครื่องยนต์และส่วนประกอบรถยนต์อื่น ๆ ได้อย่างง่ายดายโดยใช้การรวมกัน
(2) มรดก
IS-A
แพ็คเกจ com.myown.iaiti; พ่อชั้นสาธารณะ {สาธารณะ int i; โมฆะ get () {system.out.println ("พ่อ");}} แพ็คเกจลูกชาย; นำเข้า com.myown.iaiti.*; ลูกชายชั้นสาธารณะขยายพ่อ {พ่อ f = พ่อใหม่ (); get () {super.get (); system.out.println ("son");}}มีปัญหาเกี่ยวกับสิทธิ์การเข้าถึงแพ็คเกจที่นี่ หากไม่ได้เพิ่มสาธารณะค่าเริ่มต้นคือการเข้าถึงสมาชิกภายในแพ็คเกจ การเข้าถึงแพ็คเกจที่แตกต่างกันนั่นคือวิธีการเข้าถึงของสมาชิกพ่อในลูกชายนั้นมองไม่เห็น และคำพูดสาธารณะสามารถมองเห็นได้ดังนั้นฉันจึงได้รับการเข้าถึง
ส่วนส่วนตัวไม่สามารถสืบทอดได้และเป็นของคลาสแม่ส่วนตัวในขณะที่ส่วนสาธารณะจะได้รับการสืบทอดและวิธีการที่ต้องแก้ไขสามารถเขียนใหม่ได้ แอตทริบิวต์ที่จะเพิ่มสามารถเพิ่มแยกต่างหาก
ยิ่งไปกว่านั้นหากวิธีการสาธารณะของผู้ปกครองดั้งเดิมคือการเขียนใหม่หากวิธีการสาธารณะของพ่อดั้งเดิมไม่ได้เพิ่มสาธารณะมันจะไม่ลดการมองเห็นวิธีการที่สืบทอดมาจากพ่อซึ่งหมายความว่าการมองเห็นวิธีการที่สืบทอดมาในชั้นเรียนหลักไม่สามารถลดลงได้ ซุปเปอร์หมายถึงชั้นผู้ปกครองคือพ่อ
อีกประเด็นหนึ่งคือในความเป็นจริงคลาสทั้งหมดใน Java โดยปริยายสืบทอดคลาสวัตถุ วัตถุคือคลาสหลักและคลาสอื่น ๆ เป็นคลาสย่อย ชาวต่างชาติชอบที่จะพูดถึงเรื่องนี้เป็นชั้นเรียน คลาสย่อยจะเรียกว่าคลาสที่ส่งออกหรือคลาสที่ได้รับ
(3) ตัวแทน
มีวิธีที่ค่อนข้างยากที่จะเข้าใจในรูปแบบการออกแบบ - โมเดลตัวแทน ผู้เขียนพูดถึงเรื่องนี้ที่น่าสนใจมาก ตัวแทนคือหลักคำสอนของค่าเฉลี่ยของการรวมกันและการสืบทอด
แพ็คเกจลูกชาย; พ่อชั้นเรียน {โมฆะสาธารณะ get () {system.out.println ("พ่อ"); }} ลูกชายระดับสาธารณะขยายพ่อ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {พ่อ f = พ่อใหม่ (); f.get (); }} ชั้นเรียนพ่อ Proxy {พ่อเอกชน f = พ่อใหม่ (); โมฆะสาธารณะ get () {f.get (); -หากคุณปฏิบัติต่อพ่อโดยตรงในฐานะสมาชิกแล้ววิธีการของพ่อจะได้สัมผัสกับชั้นเรียนนี้ จากนั้นเราสามารถใช้ชั้นเรียนพร็อกซีเช่น Fatherproxy ฉันกำหนดวิธีการรับวิธีการด้วยตัวเอง ฉันรู้ว่ามันกำลังเรียกวิธีการของพ่อ แต่คนที่ใช้พร็อกซีของฉันไม่รู้ ฉันแค่บอกเขาว่าถ้าคุณต้องการใช้มันเพียงแค่ใช้วิธีการรับของพร็อกซี การห่อหุ้มสะท้อนให้เห็น ข้างต้นเป็นเพียงตัวอย่างง่ายๆของการเคาะแบบสุ่ม
(4) เขียนใหม่และโหลดซ้ำ
ชั้นเรียนพ่อ {โมฆะสาธารณะรับ (สตริง s) {system.out.println ("พ่อ"); } โมฆะสาธารณะรับ (บูลีน b) {system.out.println ("บูลีน"); }} ลูกชายระดับสาธารณะขยายพ่อ {@Override โมฆะสาธารณะ Get (String S) {System.out.println ("พ่อ"); } // @Override // จะมีข้อความแสดงข้อผิดพลาดเนื่องจากคลาสพาเรนต์ไม่มีวิธีนี้มันไม่ใช่การเขียนโมฆะสาธารณะอีกครั้ง (int i) {system.out.println ("sonint"); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {son s = ลูกชายคนใหม่ (); S.Get ("D"); s.get (เท็จ); s.get (1); -การเขียนใหม่คือการเขียนวิธีการของคลาสแม่อีกครั้ง หากไม่มีการเขียนซ้ำหรือการโอเวอร์โหลดเมื่อคลาสย่อยเรียกวิธีการที่ subclass ไม่มีมันจะเรียกคลาสพาเรนต์
การโอเวอร์โหลดเป็นชื่อวิธีเดียวกัน แต่ชื่อพารามิเตอร์แตกต่างกัน เพื่อป้องกันไม่ให้คุณมากเกินไปไม่ถูกต้องคุณสามารถเพิ่มแท็ก @Override ซึ่งจะแจ้งให้คุณทราบว่าคุณยังไม่ได้เขียนวิธีการใหม่
(5) ได้รับการปกป้อง
คำอธิบายโดยละเอียดเกี่ยวกับรหัสควบคุมสำหรับสิทธิ์การเข้าถึงการเขียนโปรแกรม Java
ฉันเขียนบทความก่อนหน้านี้ล่วงหน้าเพราะฉันไม่ได้พูดถึงมรดกมาก่อน
คุณสามารถมองว่าได้รับการคุ้มครองว่าเป็นมรดกของคลาสแม่ไปยังลูกชายและไม่สามารถเข้าถึงคลาสอื่น ๆ ที่ไม่ได้รับการรับรองได้
(6) คำหลักสุดท้าย
การเพิ่มประเภทพื้นฐานของคำหลักสุดท้ายหมายความว่าตัวแปรนี้จะไม่เปลี่ยนแปลงหลังจากเริ่มต้น คล้ายกับคำจำกัดความ C คุณต้องการให้ตัวแปรในโปรแกรมนี้เป็นค่านี้โดยไม่ต้องเปลี่ยน คุณสามารถใช้สุดท้าย
ลูกชายชั้นเรียนสาธารณะ {อายุ int = 2; โมฆะคงที่สาธารณะหลัก (สตริง [] args) {สุดท้าย int i = 1; // i = 2; ค่าไม่สามารถเปลี่ยนแปลงได้อีกต่อไปลูกชายคนสุดท้ายลูกชาย = ลูกชายคนใหม่ (); // son = ลูกชายคนใหม่ (); // ไม่สามารถกำหนดลูกชายตัวแปรท้องถิ่นสุดท้ายได้ // มันจะต้องว่างเปล่าและไม่ได้ใช้การมอบหมายแบบผสม // ลูกชายตัวแปรท้องถิ่นที่แก้ไขโดยสุดท้ายไม่สามารถกำหนดได้จะต้องว่างเปล่าหรือไม่ได้จัดสรรอีกครั้ง son.age = 4; // แม้ว่าการอ้างอิงจะคงที่วัตถุนั้นสามารถเปลี่ยนแปลงได้ } การเปลี่ยนแปลงเป็นโมฆะ (int สุดท้าย c) {// c = this.age; ไม่สามารถกำหนดค่าใหม่ได้เนื่องจากค่าจะกำหนดเฉพาะการอ้างอิงวัตถุเมื่อวิธีการผ่านพารามิเตอร์และกำหนดการอ้างอิงวัตถุนั้นคล้ายกับ // age ++ นี้ ไม่สามารถเปลี่ยนแปลงได้}} แบบคงที่เป็นการเริ่มต้นแบบคงที่และมันถูกใช้กับขั้นสุดท้ายเพื่อครอบครองพื้นที่จัดเก็บข้อมูลที่ไม่สามารถเปลี่ยนแปลงได้
สุดท้ายคงที่เป็นค่าคงที่ในช่วงระยะเวลาการรวบรวม ชื่อคงที่ถูกตั้งชื่อตามแบบดั้งเดิมตามค่าคงที่ของ c ทั้งหมดเป็นตัวพิมพ์ใหญ่และคำศัพท์ถูกคั่นด้วยขีดเส้นใต้
ค่าคงที่ value_one = 1;
เมื่อแก้ไขวิธีสุดท้าย
การพิมพ์คลาสสาธารณะ {void สุดท้ายไม่สามารถพิมพ์ () {system.out.println (1); }} คลาสสาธารณะ printson ขยายการพิมพ์ {// void ไม่สามารถพิมพ์ () {} // ไม่สามารถเขียนใหม่ได้เนื่องจากมีการแก้ไขโดยโมฆะคงที่สาธารณะสุดท้าย (สตริง [] args) {printson ps = new printson (); ps.cannotprint (); -มันถือได้ว่าเป็นทรัพย์สินที่ไม่ได้แก้ไข (มรดกของบรรพบุรุษ) ที่ชั้นพาเรนต์ต้องการให้ชั้นเด็กต้องได้รับมรดก ส่วนตัวถูกระบุโดยปริยายว่าเป็นครั้งสุดท้ายเพราะส่วนตัวไม่ได้ให้มรดกคุณเลย นี่เป็นเรื่องส่วนตัวมากกว่าการมรดกให้คุณ แต่ไม่ได้แก้ไข
โดยวิธีการล้างสิทธิ์
เมื่อสุดท้ายแก้ไขคลาสมันคือการป้องกันไม่ให้คลาสนี้ถูกสืบทอด
(7) มรดกและการเริ่มต้น
ปัญหาการสั่งซื้อที่นี่เป็นคำถามที่น่าสนใจ ดูตัวอย่าง
ปู่ชั้น {ส่วนตัวคงที่ int i = print (); private static int print () {system.out.println ("g"); กลับ 1; }} ชั้นเรียนพ่อขยายปู่ {private static int i = print (); private static int print () {system.out.println ("f"); กลับ 1; }} ลูกชายระดับสาธารณะขยายพ่อ {ส่วนตัวคงที่ int i = print (); private static int print () {system.out.println ("s"); กลับ 1; } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {system.out.println ("แรก"); - ผลการพิมพ์เป็นอันดับแรกหรือไม่? ผิด.
แม้ว่าวิธีการหลักจะถูกดำเนินการ แต่ฉันเห็นว่าลูกชายซึ่งต้องใช้การเริ่มต้นแบบคงที่ไม่มีมัน แต่ผลลัพธ์คือ S ก่อน?
นอกจากนี้ยังมีปัญหาของการเริ่มต้น ลูกชายสืบทอดพ่อดังนั้นคอมไพเลอร์จะโหลดพ่อและเริ่มต้นฉัน หากพ่อสืบทอดปู่แล้วคอมไพเลอร์จะโหลดปู่คล้ายกับการเรียกซ้ำ
คนสุดท้ายที่เริ่มต้นคือปู่ของฉัน
ดังนั้นผลลัพธ์สุดท้ายคือ: G, F, S, ก่อน
สรุป
ข้างต้นเป็นคำอธิบายโดยละเอียดทั้งหมดของรหัสมัลติเพล็กซิ่ง Java ในบทความนี้ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงหัวข้ออื่น ๆ ที่เกี่ยวข้องในเว็บไซต์นี้ต่อไป หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!