ตอนนี้วิธีที่ดีที่สุดในการเรียนรู้คือการดูโค้ดที่ใช้งานจริง
ตามทฤษฎีแล้ว เรามาเขียนโค้ดคลาสของเราเองกันเถอะ
ฉันจะลบทุกอย่างและเริ่มต้นใหม่ทั้งหมด
และสมมุติว่าเราทำงานให้กับบริษัทเกม และบริษัทเกมนี้มีเกมตัวช่วยสร้างที่พวกเขาต้องการสร้าง
เกือบจะเหมือนกับ Harry Potter
ทีนี้ เราจะคิดอย่างไรเกี่ยวกับมัน การเขียนโปรแกรมเชิงวัตถุ?
สิ่งแรกที่เราต้องการคือเราต้องมีผู้เล่น
ถูกต้อง.
ผู้เล่นแต่ละคนมีตัวละครที่พวกเขาต้องการเล่น
มาสร้างคลาสที่นี่และเรียกมันว่าผู้เล่น
อักขระ.
อีกครั้ง.
สังเกตแบบแผนการตั้งชื่อเพราะเป็นคลาส
และ.
กฎอีกข้อหนึ่งคือโดยปกติคุณต้องการให้เป็นเอกพจน์ ไม่ใช่พหูพจน์
ดังนั้นคุณไม่สามารถพูดตัวละครของผู้เล่นได้เพราะฉันหมายถึงมันเป็นพิมพ์เขียว
จากพิมพ์เขียวนี้ เราจะสร้างตัวละครจำนวนมาก แต่สิ่งเหล่านี้จะเป็นวัตถุ
ตัวละครผู้เล่นเดี่ยวในเอกพจน์
ในที่นี้ ฉันจะทำบางสิ่งและจะเตือนคุณ มันอาจจะดูสับสนในตอนแรก
แต่อดทนไว้
ฉันจะอธิบายมัน
เราจะกำหนดขีดล่าง ขีดล่างในนั้น
ขีดล่าง, ขีดล่าง.
ในนี้เราจะบอกตัวเองว่า
แล้วตั้งชื่อให้มัน
ชื่อของตัวละคร
จากนี้ไป เราจะทำ Colin อีกครั้ง
แล้วพูดชื่อจุดตัวเอง
เท่ากับชื่อ.
โอ้เด็ก.
เกิดอะไรขึ้นที่นี่?
อีกครั้ง ฉันจะหยุดอธิบายว่าสิ่งนี้ทำอะไร และเพียงแค่เขียนโค้ดเพิ่มอีกสองสามบรรทัดเพื่อให้เข้าใจได้ง่ายขึ้น
ฉันจะเขียนวิธีอื่นในนี้ และฉันจะนิยาม สมมุติว่า วิธีการวิ่งที่ผู้เล่นแต่ละคนสามารถเรียกใช้ได้
และในนี้ฉันจะมีห้องส่วนตัวที่แปลกประหลาดนี้อีกครั้งแล้วเข้าไปข้างในนี้พูดว่าพิมพ์
วิ่ง.
เอาล่ะ ฉันเพิ่งสร้างคลาสนี้ขึ้นมา
มันยังคงค่อนข้างสับสน
เราไม่รู้จริงๆ ว่าสิ่งนี้คืออะไร ตัวตนคืออะไร และรูปลักษณ์ใหม่ทั้งหมดนี้
แต่ขอเพิกเฉยสักครู่แล้วพูดง่ายๆ
ผู้เล่น
หนึ่งจะเท่ากับตัวละครของผู้เล่นและยกตัวอย่างผู้เล่นคนนั้น
ดังนั้น.
เราสามารถพิมพ์เครื่องเล่นและดูว่ามีอะไรขึ้นกับเครื่องเล่นนี้
ถ้าฉันคลิกเรียกใช้
เอาล่ะฉันได้รับอากาศ
เป็นประเภทอากาศ
มันบอกว่าไม่มีชื่ออาร์กิวเมนต์ตำแหน่งที่ต้องการหนึ่งชื่อ
ไม่เป็นไร.
ลองพักที่นี่และดูว่าเกิดอะไรขึ้นที่นี่
คุณเห็นนี้ innit?
วิธีการเป็นวิธีการพิเศษ
คุณเห็นทั้งสองขีดเส้นใต้ที่นี่
นี้เรียกว่าวิธีโง่เขลาหรือวิธีวิเศษ
และเราจะมีวิดีโอเกี่ยวกับเรื่องนี้โดยเฉพาะ
แต่เมื่อเราสร้างชั้นเรียน คุณมักจะเห็นสิ่งนี้ที่ด้านบนสุด
และนี่คือสิ่งที่มักเรียกว่า คอนสตรัคเตอร์ เมธอด หรือ เมธอด init
และสิ่งนี้จะถูกเรียกโดยอัตโนมัติทุกครั้งที่เรายกตัวอย่าง
จำ Instantiate หมายความว่าเรากำลังเรียกชั้นเรียนเพื่อสร้างวัตถุ
ดังนั้นเมื่อฉันทำสิ่งนี้ มันจะเรียกใช้สิ่งที่อยู่ในบล็อคโค้ดนี้โดยอัตโนมัติ
เมื่อฉันเรียกใช้สิ่งนี้ คุณจะเห็นว่าฉันได้รับข้อผิดพลาดออนไลน์เก้าที่นี่ ออนไลน์
เก้า.
และเมื่อฉันพยายามยกตัวอย่างตัวละครของผู้เล่น
มันวิ่งเข้าไปแล้วก็พยายามทำเอง
ชื่อเท่ากับชื่อ
แต่ปัญหาคือฉันไม่ได้ให้ชื่ออาร์กิวเมนต์แก่มัน
และนั่นเป็นเพราะเมื่อเราเรียกมัน เรายอมรับสิ่งที่อยู่หลังตัวเองเป็นพารามิเตอร์
ชื่อ.
เราจึงต้องตั้งชื่อให้ตัวละครตัวนี้
สมมุติว่าชื่อซินดี้
ถ้าฉันคลิกเรียกใช้ที่นี่
ไม่เป็นไร.
ดูเหมือนว่าฉันมีตัวละครผู้เล่น
และที่จริงแล้ว มันแสดงให้ฉันเห็นว่ามันเป็นวัตถุที่ตำแหน่งหน่วยความจำนี้
ดังนั้นในคอมพิวเตอร์ของเรา นี่คือตำแหน่งที่ตัวละครของผู้เล่นคนหนึ่งตั้งอยู่ในขณะนี้
เจ๋งมาก.
แต่คีย์เวิร์ดตัวเองนี้คืออะไร และโค้ดนี้ออนไลน์มีไว้เพื่ออะไร
นี่เป็นวิธีที่เราจะกำหนด
ตัวเองหมายถึงตัวละครของผู้เล่น
มันบอกว่า เฮ้ นี่หมายถึงตัวละครของผู้เล่นที่เรากำลังจะสร้างผู้เล่นคนหนึ่ง
และฉันต้องการให้ชื่อจุดในตัวเองเท่ากับชื่อพารามิเตอร์ใดก็ตาม
เพื่อที่ว่าถ้าฉันทำชื่อผู้เล่นที่นี่และฉันคลิกเรียกใช้
ฉันเข้าใจซินดี้
แล้วทำไมถึงเป็นซินดี้ล่ะ?
เพราะฉันให้ตัวละครผู้เล่นพารามิเตอร์
และเมื่อฉันสร้างอินสแตนซ์ ฉันส่งพารามิเตอร์ชื่อ
พารามิเตอร์เริ่มต้นคือตัวเองเมื่อฉันทำในนั้นและในคลาส คุณจะเห็นว่าค่าดีฟอลต์เป็นพารามิเตอร์แรกเสมอเมื่อเรากำหนดเมธอดคือตัวเอง
และตอนนี้ฉันให้ชื่อตัวเองดอทชื่อ
จะเกิดอะไรขึ้นหากฉันลบสิ่งนี้ที่นี่แล้วคลิกเรียกใช้
คุณเห็นว่ามันบอกว่าวัตถุไม่มีชื่อแอตทริบิวต์
เพราะถึงจะพูดว่า เฮ้ อยากให้ผู้เล่นมีชื่อ ต้องบอกตัวเองว่าดอท
เพราะตัวเองหมายถึงผู้เล่นคนหนึ่ง
ถ้าคุณจำตอนที่เรามีรายการ เราต้องทำ dot แล้วเราจะบอกว่าผนวก
มีคนเขียนโค้ดต่อท้ายนี้ และโค้ดต่อท้ายจะเขียนว่า self dot
สมมติว่าเพิ่มในรายการและอ้างถึงตัวเองในสิ่งที่อยู่ทางซ้ายของจุด
ด้วยวิธีนี้จะช่วยให้เราสามารถอ้างอิงถึงสิ่งที่ยังไม่ได้สร้างขึ้นในกรณีนี้
ผู้เล่นที่หนึ่ง และให้พวกเขารู้ว่า เฮ้ เมื่อมันถูกสร้างขึ้น เมื่อเรายกตัวอย่าง
ฉันต้องการให้คุณแน่ใจว่าผู้เล่นที่หนึ่งมีแอตทริบิวต์ชื่อนี้ เพื่อที่ว่าถ้าฉันสร้างผู้เล่นอื่นและผู้เล่น Tom
จะเป็นผู้เล่นที่สอง
ถ้าฉันพิมพ์ชื่อเครื่องเล่นและฉันคลิกเรียกใช้
ฉันมีผู้เล่นสองคนที่มีชื่อต่างกันสองชื่อ
ฉันสามารถใช้โค้ดชิ้นเดียวกันได้ แต่มีค่าต่างกันเพราะตัวฉันเอง ทุกครั้งที่ฉันสร้างอินสแตนซ์นี้หมายถึงผู้เล่นครั้งแรกที่หนึ่ง
จากนั้นครั้งที่สองในครั้งแรกคือผู้เล่นที่สอง
ตอนนี้ตัวเองเป็นหนึ่งในสิ่งเหล่านั้นที่เข้าใจยากจริงๆ
และคุณอาจต้องดูวิดีโอนี้สองสามครั้ง แต่สิ่งสำคัญในที่นี้ควรชัดเจนสำหรับคุณ
นั่นคือฉันสามารถเขียนโค้ดได้เพียงครั้งเดียว
จำหลักการขับเคลื่อนของเราได้หรือไม่?
อย่าทำซ้ำตัวเอง
และฉันสามารถทำให้มันเป็นไดนามิกโดยบอกว่าข้อมูลที่เราจะสร้างสำหรับออบเจกต์นั้นจะเป็นไดนามิก
และมันจะเปลี่ยนแปลงไปตามสิ่งที่เราให้
เพื่อให้ผมสามารถสร้างผู้เล่นที่แตกต่างกันด้วยคุณลักษณะที่แตกต่างกัน
แต่ยังคงใช้รหัสเดิม
ตอนนี้ฉันสามารถมีได้หลายอย่างที่นี่
ฉันสามารถมี H เป็นตัวอย่าง และอีกครั้งฉันสามารถพูดได้ว่าตัวเอง h เท่ากับ H แล้วซินดี้จะต้องผ่าน
สมมติว่า 44 และโธมัส 21
เพื่อว่าที่นี่อีกครั้งถ้าฉันอายุมากขึ้น
พวกเขาจะมีคุณสมบัติที่แตกต่างกัน
โปรดจำไว้ว่า สิ่งเหล่านี้คือแอตทริบิวต์หรือคุณสมบัติที่วัตถุเหล่านี้มี และคุณสามารถเข้าถึงได้โดยการทำเครื่องหมายจุดแล้วเข้าถึงคุณสมบัตินั้นเอง
คุณเห็นไหมว่าฉันไม่มีวงเล็บในที่นี้ เพราะไม่ใช่วิธี ไม่ได้ดำเนินการ
พูดง่ายๆ ว่า เฮ้ ฉันต้องการเข้าถึงแอตทริบิวต์นี้
ถ้าฉันจุดตรงนี้ บรรณาธิการจะบอกฉัน และเราจะมีสัญลักษณ์สำหรับ เฮ้ คุณสามารถเข้าถึงแอตทริบิวต์
อายุ และชื่อได้
และตามจริงแล้ว ฉันยังมีสิทธิ์เข้าถึงเพื่อเรียกใช้เมธอดนั้นด้วย ดังนั้นหากฉันคลิกเรียกใช้
จำไว้ว่าการวิ่งเป็นวิธีหนึ่ง
ดังนั้นฉันจึงได้รับวิธีการผูกมัดนี้ แต่ไม่ได้พิมพ์อะไรเลย ไม่ได้ดำเนินการใดๆ
ดังนั้นเราต้องเพิ่มวงเล็บอีกครั้ง
ตี, วิ่ง.
และดูนั่นสิ
ฉันสามารถวิ่งได้
จากนั้นฉันก็ไม่มี
แล้ว 21.
ทำไมเราถึงได้รับสิ่งนี้
ไม่มี?
เพราะจำไว้ว่านี่เป็นฟังก์ชันที่ไม่ส่งคืนอะไรเลย
เมื่อฟังก์ชั่นไม่ส่งคืนสิ่งใด เราจะได้อะไร?
เราไม่ได้รับ
บางทีผมบอกได้คำเดียวว่า return done
ถ้าฉันคลิกเรียกใช้
ไปเลย
เราวิ่งเสร็จแล้ว 21
สิ่งสุดท้ายก่อนที่ฉันจะจบวิดีโอนี้
สิ่งที่น่าสนใจที่นี่คือถ้าฉันทำผู้เล่นคนหนึ่ง
จากนั้นผู้เล่นสองคนและฉันพิมพ์สิ่งนี้แล้วคลิกเรียกใช้
คุณจะเห็นว่าฉันได้รับตัวละครของผู้เล่น
แต่วัตถุแต่ละวัตถุเหล่านี้ ผู้เล่นที่หนึ่งและผู้เล่นสองคนอยู่ในตำแหน่งหน่วยความจำที่ต่างกัน
ดังนั้นฉันจึงสามารถใช้โค้ดชิ้นเดียว พิมพ์เขียวเดียวเพื่อสร้างผู้เล่นหลายคนได้
แต่ผู้เล่นเหล่านี้ไม่เหมือนกัน
พวกมันถูกสร้างขึ้นจากพิมพ์เขียวเดียวกัน แต่พวกมันอาศัยอยู่ในที่ต่าง ๆ ในความทรงจำ
และนั่นก็สมเหตุสมผลใช่มั้ย?
เราไม่ต้องการให้ Tom และ Cindy เป็นผู้เล่นคนเดียวกัน
พวกเขาสองคนเป็นผู้เล่นที่แตกต่างกัน
ด้วยวิธีนี้ เราสามารถรักษาสิ่งต่างๆ ให้ปลอดภัยได้
และอะไรก็ตามที่ฉันเพิ่มไปยังผู้เล่นที่สอง ตัวอย่างเช่น สมมติว่าผู้เล่นที่สองสามารถโจมตีได้แล้ว
และการโจมตีจะเป็นเพียงแค่คุณสมบัติที่จะเป็น 50
ถ้าฉันไม่โจมตีที่นี่ คุณจะเห็นว่าผู้เล่นสองคนมี
จู่โจม.
แต่ถ้าผมเล่นหรือต้องการจู่โจม
ฉันจะได้รับอากาศ
วัตถุไม่มีแอตทริบิวต์
จู่โจม.
ฉันหวังว่าคุณจะเริ่มเห็นพลังของชั้นเรียน
แม้ว่ามันอาจจะยากที่จะเข้าใจในตอนแรก
พลังจะปรากฏชัดเมื่อเราสามารถสร้างพิมพ์เขียวนี้ ซึ่งตอนนี้เราสามารถใช้ซ้ำแล้วซ้ำอีกเพื่อสร้างวัตถุของเราเอง
มาสำรวจกันเพิ่มเติมในวิดีโอหน้า