ยินดีต้อนรับกลับ.
ในวิดีโอที่แล้ว ฉันแสดงให้คุณเห็นถึงวิธีการเรียกใช้เมธอดจากคลาสย่อยของคลาสพาเรนต์
ในกรณีของเรา เราทำ user dot attack
เพื่อเรียกใช้วิธีการโจมตีและผู้ใช้
ตอนนี้ฉันได้ลบวิธีการโจมตีแล้วเพราะฉันต้องการลองสิ่งที่แตกต่างออกไป
ฉันต้องการสร้างฟังก์ชัน init ที่นี่ และฟังก์ชัน init นี้จะใช้ตัวเอง
แล้วสมมติว่าผู้ใช้จะได้รับ สมมุติว่าอีเมล
เพราะผู้ใช้เกมของเราทุกคนต้องมีอีเมล
และในที่นี้ เราจะบอกว่า self dot email จะเท่ากับอีเมล
ดีและเรียบง่าย
ตอนนี้อยู่ในนี้
ถ้าฉันจะเรียกใช้รหัสนี้และขอลบ user dot attack ออกก่อน
ดังนั้นเราจึงมีตัวช่วยสร้างเดียวกันกับที่เราเพิ่งเพิ่มเข้าไป หรือขออภัยในสิ่งนี้
และเรามีตัวช่วยสร้างของเราชนะ
ดังนั้น ถ้าฉันเรียกใช้ตัวช่วยสร้างที่นี่ และสมมติว่าเราต้องการเรียกใช้อีเมล Wizard one dot
ถ้าฉันคลิกเรียกใช้
อืม.
ฉันเข้าใจ.
วัตถุตัวช่วยสร้างไม่มีแอตทริบิวต์
อีเมล.
อืม.
แต่ฉันคิดว่าผู้ใช้จะถูกเรียกเมื่อเราสร้างตัวช่วยสร้างใช่ไหม
เมื่อเรายกตัวอย่าง Wizard One
สิ่งนั้นก็คือ แม้ว่าเราอาจสืบทอดมา สมมุติว่า ถ้าผมดอท เราอาจสืบทอด
เข้าสู่ระบบ.
จากผู้ใช้.
และถ้าผมกด run เราจะเห็นว่าเราสืบทอดมา
วิซาร์ดมีฟังก์ชัน init อยู่แล้ว constructor ใช่ไหม?
แล้วเราจะแก้ปัญหานี้ได้อย่างไร?
วิธีหนึ่งคือเพียงแค่เพิ่มอีเมลที่นี่ใช่ไหม
และเพียงแค่มีอีเมล
แอตทริบิวต์ตรงนี้
แต่ปัญหาของเรื่องนี้คืออะไร?
มันไม่มีประสิทธิภาพใช่มั้ย?
เพราะถ้าฉันสร้างคลาส Archer ฉันก็ต้องทำแบบเดียวกัน
และเมื่อเรารู้ว่าแอตทริบิวต์เหล่านี้ทั้งหมดจะเหมือนกันในคลาสย่อยทั้งหมดของเรา เราต้องการทำที่นี่
วิธีที่มีประสิทธิภาพมากขึ้นในการทำเช่นนี้คืออะไร?
เราต้องการเรียกวิธีการ init ของผู้ใช้จากภายในที่นี่
ถูกต้อง.
เพราะทุกครั้งที่เราสร้างตัวช่วยสร้างใหม่ ฟังก์ชัน init นี้จะถูกเรียกใช้
วิธีที่จะทำคือบอกว่าผู้ใช้ดอท
ขีดเส้นใต้ในนั้น
แล้วให้มันเป็นตัวตน
แล้วก็อีเมล์
แล้วอีเมลก็เป็นสิ่งที่เราส่งผ่านเข้ามา
ถ้าฉันลงไปตรงนี้ ฉันบอกได้เลย
เมอร์ลินที่ gmail com จะเป็นอีเมล
ว่าตอนนี้ถ้าฉันทำ สมมุติว่า
อีเมล Dot สำหรับ Wizard One และฉันคลิกเรียกใช้
ฉันได้รับอีเมลของเมอร์ลินอีกครั้ง
ทั้งหมดที่เราทำคือเราเรียกวิธี init
ของผู้ใช้ภายในวิซาร์ด
ดังนั้น เมื่อเราสร้างตัวช่วยสร้างใหม่ เราเรียกใช้ฟังก์ชันนี้ และภายในฟังก์ชันนี้ เรารันผู้ใช้ dot
init และส่งผ่านในอีเมลที่เราส่งผ่านเป็นอาร์กิวเมนต์ในที่นี้
นี่เป็นวิธีหนึ่งในการทำ
แล้วก็มีอีกทางหนึ่งที่เรียกว่าซุปเปอร์
และเป็นคำสำคัญ
อย่างที่คุณเห็น กำลังถูกเน้นที่นี่
และทั้งหมดที่เราทำคือวิ่งอย่างสุดยอด
และ Super หมายถึง superclass หรือ class above wizard ซึ่งเป็นผู้ใช้
และนี่เป็นส่วนเสริมใหม่ของ Python 2 2.
ด้วย Super เราไม่ต้องการตัวตนอีกต่อไป ดังนั้นโค้ดของเราจึงดูสะอาดตายิ่งขึ้น และสิ่งที่เราส่งผ่านก็คือสิ่งนี้
และหากเราคลิกเรียกใช้
เรายังคงได้รับคำตอบที่ถูกต้อง
ซุปเปอร์.
ช่วยให้เราสามารถอ้างอิงถึงผู้ใช้ได้ด้วยวิธีนี้และไม่ต้องกังวลกับการส่งต่อตนเอง