วิธีอธิบายแนวคิดการเขียนโปรแกรมเชิงวัตถุสำหรับเด็ก 6 ขวบ

คุณสังเกตไหมว่าคำถามที่ซ้ำซากจำเจมักถูกถามในการสัมภาษณ์งานซ้ำแล้วซ้ำอีกหรือไม่?

ฉันแน่ใจว่าคุณรู้ว่าฉันหมายถึงอะไร

ตัวอย่างเช่น:

คุณเห็นตัวเองที่ไหนในห้าปี?

หรือแย่กว่านั้น:

อะไรที่คุณคิดว่าเป็นจุดอ่อนที่สุดของคุณ?

ฮึ…ขอพักหน่อย ฉันถือว่าการตอบคำถามนี้เป็นจุดอ่อนอย่างยิ่ง! อย่างไรก็ตามไม่ใช่ประเด็นของฉัน

คำถามเหล่านี้อาจเป็นเรื่องเล็กน้อย แต่ก็มีความสำคัญเพราะให้เบาะแสเกี่ยวกับคุณ สภาพจิตใจทัศนคติมุมมองของคุณในปัจจุบัน

เมื่อตอบคุณควรระมัดระวังเพราะคุณอาจเปิดเผยสิ่งที่คุณเสียใจในภายหลัง

วันนี้ฉันต้องการพูดคุยเกี่ยวกับคำถามประเภทเดียวกันในโลกของการเขียนโปรแกรม:

อะไรคือหลักการสำคัญของ Object-Oriented Programming?

ฉันได้รับทั้งสองด้านของคำถามนี้ เป็นหนึ่งในหัวข้อที่ถูกถามบ่อยมากจนคุณไม่สามารถปล่อยให้ตัวเองไม่รู้ได้

นักพัฒนารุ่นเยาว์และระดับเริ่มต้นมักจะต้องตอบคำถามนี้ เพราะเป็นวิธีที่ง่ายสำหรับผู้สัมภาษณ์ที่จะบอกสามสิ่ง:

  1. ผู้สมัครเตรียมตัวสำหรับการสัมภาษณ์ครั้งนี้หรือไม่?

    คะแนนโบนัสหากคุณได้ยินคำตอบทันที - แสดงถึงแนวทางที่จริงจัง

  2. ผู้สมัครผ่านขั้นตอนการสอนหรือไม่

    การทำความเข้าใจหลักการของ Object-Oriented Programming (OOP) แสดงให้เห็นว่าคุณก้าวไปไกลกว่าการคัดลอกและวางจากบทช่วยสอน - คุณได้เห็นสิ่งต่างๆจากมุมมองที่สูงขึ้นแล้ว

  3. ความเข้าใจของผู้สมัครนั้นลึกหรือตื้น?

    ระดับของความสามารถกับคำถามนี้มักจะเท่ากับระดับของความสามารถในวิชาอื่น ๆ มากที่สุด เชื่อฉัน.

สี่หลักการของการเขียนโปรแกรมเชิงวัตถุมีการห่อหุ้ม , นามธรรม , มรดก ,และความแตกต่าง

คำเหล่านี้อาจฟังดูน่ากลัวสำหรับนักพัฒนารุ่นเยาว์ และบางครั้งคำอธิบายที่ซับซ้อนและยาวเกินไปในวิกิพีเดียก็ทำให้เกิดความสับสนเป็นสองเท่า

นั่นเป็นเหตุผลที่ฉันต้องการให้คำอธิบายที่เรียบง่ายสั้นและชัดเจนสำหรับแต่ละแนวคิดเหล่านี้ อาจฟังดูเหมือนคุณอธิบายให้เด็กฟัง แต่จริงๆแล้วฉันชอบที่จะได้ยินคำตอบเหล่านี้เมื่อฉันทำการสัมภาษณ์

การห่อหุ้ม

สมมติว่าเรามีโปรแกรม มันมีออบเจ็กต์ที่แตกต่างกันทางตรรกะสองสามอย่างซึ่งสื่อสารกัน - ตามกฎที่กำหนดไว้ในโปรแกรม

การห่อหุ้มจะทำได้เมื่อแต่ละออบเจ็กต์คงสถานะเป็นส่วนตัวไว้ภายในคลาส วัตถุอื่น ๆ ไม่สามารถเข้าถึงสถานะนี้ได้โดยตรง แต่สามารถเรียกใช้เฉพาะรายการฟังก์ชันสาธารณะที่เรียกว่าเมธอดเท่านั้น

ดังนั้นวัตถุจึงจัดการสถานะของตัวเองผ่านวิธีการ - และไม่มีคลาสอื่นใดสามารถสัมผัสได้เว้นแต่จะได้รับอนุญาตอย่างชัดเจน หากคุณต้องการสื่อสารกับวัตถุคุณควรใช้วิธีการที่มีให้ แต่ (โดยค่าเริ่มต้น) คุณไม่สามารถเปลี่ยนสถานะได้

สมมติว่าเรากำลังสร้างเกม Sims ตัวจิ๋ว มีคนและมีแมว พวกเขาสื่อสารกัน เราต้องการใช้การห่อหุ้มดังนั้นเราจึงรวมตรรกะ "cat" ทั้งหมดไว้ในไฟล์Catชั้นเรียน. อาจมีลักษณะดังนี้:

ที่นี่“รัฐ” ของแมวเป็นตัวแปรส่วนตัวmood , และhungry นอกจากนี้ยังมีวิธีการส่วนตัวenergy มันสามารถเรียกมันได้ทุกเมื่อที่ต้องการส่วนคลาสอื่น ๆ ไม่สามารถบอกแมวได้ว่าจะเหมียวเมื่อไหร่meow()

สิ่งที่พวกเขาสามารถทำได้คือการที่กำหนดไว้ในวิธีการสาธารณะsleep() , และplay() แต่ละของพวกเขาปรับเปลี่ยนสถานะภายในอย่างใดและอาจก่อให้เกิด ดังนั้นการผูกมัดระหว่างรัฐเอกชนและวิธีการสาธารณะจึงเกิดขึ้นfeed()meow()

นี่คือการห่อหุ้ม

สิ่งที่เป็นนามธรรม

สิ่งที่เป็นนามธรรมสามารถคิดได้ว่าเป็นส่วนขยายตามธรรมชาติของการห่อหุ้ม

ในการออกแบบเชิงวัตถุโปรแกรมมักมีขนาดใหญ่มาก และวัตถุที่แยกจากกันสื่อสารกันเป็นจำนวนมาก ดังนั้นการดูแล codebase ขนาดใหญ่เช่นนี้เป็นเวลาหลายปีพร้อมกับการเปลี่ยนแปลงระหว่างทางจึงเป็นเรื่องยาก

Abstraction เป็นแนวคิดที่มีเป้าหมายเพื่อบรรเทาปัญหานี้

การประยุกต์ใช้สิ่งที่เป็นนามธรรมหมายความว่าวัตถุแต่ละคนควรเพียงเปิดเผยกลไกระดับสูงสำหรับการใช้มัน

กลไกนี้ควรซ่อนรายละเอียดการใช้งานภายใน ควรเปิดเผยเฉพาะการดำเนินการที่เกี่ยวข้องกับวัตถุอื่น ๆ

Think - เครื่องชงกาแฟ มันทำหลายอย่างและส่งเสียงแปลก ๆ ภายใต้ฝากระโปรง แต่สิ่งที่คุณต้องทำคือใส่กาแฟแล้วกดปุ่ม

กลไกนี้ควรใช้งานง่ายและไม่ค่อยมีการเปลี่ยนแปลงเมื่อเวลาผ่านไป คิดว่าเป็นวิธีการสาธารณะชุดเล็ก ๆ ซึ่งคนชั้นอื่นสามารถเรียกได้โดยไม่ต้อง "รู้" ว่าพวกเขาทำงานอย่างไร

อีกตัวอย่างในชีวิตจริงของสิ่งที่เป็นนามธรรม?

ลองนึกถึงวิธีที่คุณใช้โทรศัพท์ของคุณ:

คุณโต้ตอบกับโทรศัพท์ของคุณโดยใช้ปุ่มเพียงไม่กี่ปุ่ม เกิดอะไรขึ้นภายใต้ประทุน? คุณไม่จำเป็นต้องรู้ - รายละเอียดการใช้งานถูกซ่อนไว้ คุณต้องรู้เพียงชุดการกระทำสั้น ๆ

การเปลี่ยนแปลงการนำไปใช้งานตัวอย่างเช่นการอัปเดตซอฟต์แวร์แทบจะไม่ส่งผลกระทบต่อสิ่งที่เป็นนามธรรมที่คุณใช้

มรดก

ตกลงเราเห็นว่าการห่อหุ้มและนามธรรมสามารถช่วยเราพัฒนาและรักษา codebase ขนาดใหญ่ได้อย่างไร

แต่คุณรู้หรือไม่ว่าปัญหาทั่วไปอีกประการหนึ่งในการออกแบบ OOP คืออะไร?

วัตถุมักจะคล้ายกันมาก พวกเขาใช้ตรรกะร่วมกัน แต่พวกเขาไม่ได้อย่างสิ้นเชิงเดียวกัน ฮึ…

แล้วเราจะนำตรรกะทั่วไปมาใช้ใหม่และแยกตรรกะเฉพาะออกเป็นคลาสแยกกันได้อย่างไร? วิธีหนึ่งที่จะบรรลุสิ่งนี้คือการถ่ายทอดทางพันธุกรรม

หมายความว่าคุณสร้างคลาส (ลูก) โดยได้มาจากคลาส (พาเรนต์) อื่น ด้วยวิธีนี้เราจะสร้างลำดับชั้น

คลาสย่อยจะใช้ฟิลด์และเมธอดทั้งหมดของคลาสพาเรนต์ (ส่วนทั่วไป) ซ้ำและสามารถใช้งานของตัวเองได้ (ส่วนที่ไม่ซ้ำกัน)

ตัวอย่างเช่น:

หากโปรแกรมของเราต้องการจัดการครูภาครัฐและเอกชน แต่รวมถึงคนประเภทอื่น ๆ เช่นนักเรียนเราสามารถใช้ลำดับชั้นนี้ได้

ด้วยวิธีนี้แต่ละคลาสจะเพิ่มเฉพาะสิ่งที่จำเป็นเท่านั้นในขณะที่นำตรรกะทั่วไปกลับมาใช้กับคลาสพาเรนต์

ความแตกต่าง

เราเป็นคำที่ซับซ้อนที่สุด! Polymorphism แปลว่า "หลายรูปทรง" ในภาษากรีก

ดังนั้นเราจึงรู้แล้วถึงพลังแห่งการสืบทอดและใช้มันอย่างมีความสุข แต่มีปัญหานี้มา

สมมติว่าเรามีคลาสผู้ปกครองและคลาสย่อยสองสามคลาสที่สืบทอดมาจากคลาสนั้น บางครั้งเราต้องการใช้คอลเลกชันตัวอย่างเช่นรายการซึ่งมีคลาสเหล่านี้ผสมกัน หรือเรามีวิธีการใช้งานสำหรับคลาสผู้ปกครอง แต่เราก็ต้องการใช้สำหรับเด็กเช่นกัน

สิ่งนี้สามารถแก้ไขได้โดยใช้ความหลากหลาย

พูดง่ายๆก็คือความหลากหลายเป็นวิธีการใช้คลาสที่เหมือนกับพาเรนต์ดังนั้นจึงไม่ต้องสับสนกับประเภทการผสมแต่เด็กแต่ละชั้นก็ยังคงใช้วิธีการของตัวเองเหมือนเดิม

โดยทั่วไปจะเกิดขึ้นโดยการกำหนดอินเทอร์เฟซ (พาเรนต์) ที่จะใช้ซ้ำ มันสรุปวิธีการทั่วไปมากมาย จากนั้นคลาสย่อยแต่ละคลาสจะใช้วิธีการเหล่านี้ในเวอร์ชันของตนเอง

เมื่อใดก็ตามที่คอลเลกชัน (เช่นรายการ) หรือเมธอดต้องการอินสแตนซ์ของพาเรนต์ (ซึ่งมีการระบุวิธีการทั่วไป) ภาษาจะดูแลประเมินการนำวิธีการทั่วไปไปใช้อย่างถูกต้องโดยไม่คำนึงว่าเด็กคนใดจะผ่าน

ดูภาพร่างการใช้งานรูปทรงเรขาคณิต พวกเขาใช้อินเทอร์เฟซทั่วไปซ้ำสำหรับการคำนวณพื้นที่ผิวและปริมณฑล:

มีทั้งสามตัวเลขสืบทอดผู้ปกครองFigure Interfaceช่วยให้คุณสามารถสร้างรายชื่อของผสมtriangles, และcircles rectanglesและปฏิบัติต่อพวกเขาเหมือนวัตถุประเภทเดียวกัน

จากนั้นหากรายการนี้พยายามคำนวณพื้นผิวสำหรับองค์ประกอบจะพบวิธีการที่ถูกต้องและดำเนินการ ถ้าองค์ประกอบเป็นสามเหลี่ยมสามเหลี่ยมCalculateSurface()ถูกเรียก. ถ้าเป็นวงกลม - ก็คือวงกลมCalculateSurface()ถูกเรียก. และอื่น ๆ

หากคุณมีฟังก์ชันที่ทำงานกับตัวเลขโดยใช้พารามิเตอร์คุณไม่จำเป็นต้องกำหนดมันสามครั้ง - หนึ่งครั้งสำหรับสามเหลี่ยมวงกลมและสี่เหลี่ยมผืนผ้า

คุณสามารถกำหนดเพียงครั้งเดียวและยอมรับไฟล์ Figureเป็นข้อโต้แย้ง ไม่ว่าคุณจะผ่านสามเหลี่ยมวงกลมหรือสี่เหลี่ยมผืนผ้าตราบใดที่ใช้งานCalculateParamter()ประเภทของมันก็ไม่สำคัญ

ฉันหวังว่านี่จะช่วยได้ คุณสามารถใช้คำอธิบายเดียวกันนี้ได้โดยตรงในการสัมภาษณ์งาน

หากคุณพบสิ่งที่ยังเข้าใจยาก - อย่าลังเลที่จะถามในความคิดเห็นด้านล่าง

อะไรต่อไป?

การเตรียมพร้อมที่จะตอบคำถามคลาสสิกคำถามสัมภาษณ์ตลอดเวลาเป็นสิ่งที่ดี - แต่บางครั้งคุณไม่เคยถูกเรียกให้สัมภาษณ์

ต่อไปฉันจะมุ่งเน้นไปที่สิ่งที่นายจ้างต้องการเห็นในนักพัฒนารุ่นเยาว์และวิธีการโดดเด่นจากฝูงชนเมื่อหางาน

คอยติดตาม.