ไม่ใช่การไม่เปลี่ยนรูปหรือการสืบทอด แต่เป็นข้อมูลเพิ่มเติมเกี่ยวกับวิธีการจัดโครงสร้างแอปพลิเคชันของคุณ
ประเภทข้อมูลพีชคณิตมีทั้งข้อดีและข้อเสีย ช่วยให้คุณสามารถเขียนแอปพลิเคชันของคุณในลักษณะที่ปลอดภัยต่อการพิมพ์ — เมื่อคุณทำการจับคู่รูปแบบ จะทำให้ประเภทข้อมูลทั้งหมดหมดสำหรับคุณ อย่างไรก็ตาม การใช้ ADT ยังมีข้อเสียหากประเภทข้อมูลของคุณเปลี่ยนแปลงอยู่ตลอดเวลา
ฉันจะตัดการไล่ล่าและให้คำตอบเกี่ยวกับความแตกต่าง เมื่อคุณเขียนแอปพลิเคชันด้วยกระบวนทัศน์การเขียนโปรแกรมเชิงฟังก์ชัน ทุกอย่างจะเป็นกลุ่มตามการดำเนินการ เมื่อเราเขียนโปรแกรมในลักษณะเชิงวัตถุ ทุกอย่างจะอยู่เป็นกลุ่มตามวัตถุ
สำหรับฉัน นี่เป็นการค้นพบครั้งยิ่งใหญ่! มันอธิบายว่าทำไมบางครั้ง ADT ถึงทำให้เกิดความเจ็บปวดได้
ฉันจะอธิบายว่านั่นหมายความว่าอย่างไร และสิ่งนี้จะทำให้คุณเข้าใจคร่าวๆ ว่าฉันคิดว่าความแตกต่างที่แท้จริงระหว่างการเขียนโปรแกรมเชิงฟังก์ชันกับการเขียนโปรแกรมเชิงวัตถุคืออะไร
มาทำให้เป็นชนิดข้อมูล Tree กันดีกว่า ในการลองสร้างต้นไม้ครั้งแรก มันจะเป็นดังนี้:
จากนั้นเราอยากได้ฟังก์ชันคำนวณความสูงของต้นไม้ มาทำที่นี่กันเถอะ:
จากนั้น เราต้องการให้ฟังก์ชันคำนวณผลรวมของสาขาทั้งหมด:
จากฟังก์ชันทั้งสองข้างต้น เราสังเกตเห็นว่าเมื่อเราสร้าง ADT แล้ว เราจะต้องนำกรณีต่างๆ ไปใช้กับ ADT แต่ละตัว — height
และ sum
จำเป็นต้องดำเนินการตามประเภทข้อมูลสองประเภท - Branch
และ Leaf
หากเราต้องการใช้สิ่งนี้ในลักษณะเชิงวัตถุ เราจะใส่วิธีการนี้ไว้ในอินเทอร์เฟซ Tree
:
ในลักษณะเชิงวัตถุ เรากำลังจัดกลุ่มการดำเนินการของเราตามแต่ละคลาส ดังนั้น Branch
จะมีฟังก์ชันของตัวเองเป็น height
และ sum
และ Leaf
จะมีฟังก์ชันของตัวเองเป็น height
และ sum
นี่เป็นสองวิธีในการจัดโครงสร้างแอปพลิเคชันของคุณซึ่งอาจมีผลกระทบต่อวิธีจัดโครงสร้างที่แตกต่างกันออกไป เรามาดูข้อดีข้อเสียของการจัดโครงสร้างด้วยวิธีนี้กัน
การเพิ่มชนิดข้อมูลใหม่
เราต้องการขยาย Tree
เพื่อให้มีข้อมูลประเภทอื่น `Empty ' ซึ่งเป็นตัวแทนของรายการย่อยที่ว่างเปล่าในแอปพลิเคชัน
หากเราใช้ Tree Type ของเรากับ ADT ในตอนแรก และจัดกลุ่มพวกมันในการดำเนินงาน เราจะต้องผ่านการดำเนินการแต่ละครั้งและเพิ่ม Empty
ในกรณีการจับคู่รูปแบบ
หากเรามีฟังก์ชันมากมายในแอปพลิเคชันของเราตามประเภทข้อมูล Tree
เราจะต้องผ่านแต่ละฟังก์ชันโดยเพิ่มตัวพิมพ์ Empty
ใหม่
อย่างไรก็ตาม หากเราทำในลักษณะเชิงวัตถุ เราเพียงแค่ต้องใช้คลาสใหม่ Empty
ที่ขยายลักษณะ Tree
ในสถานการณ์นี้ การเพิ่มประเภทข้อมูลใหม่จะยุ่งยากหากคุณจัดกลุ่มแอปพลิเคชันของคุณตามประเภทข้อมูล เนื่องจากเราจะต้องเปลี่ยนการดำเนินการทั้งหมดในแอปพลิเคชันเพื่อรวมกรณีอื่น อย่างไรก็ตาม ในลักษณะเชิงวัตถุ เนื่องจากแต่ละฟังก์ชันถูกจัดกลุ่มตามวัตถุ การเพิ่มชนิดข้อมูลใหม่จึงจำเป็นต้องใช้อินเทอร์เฟซ Tree
การเพิ่มการดำเนินการใหม่
เราต้องการเพิ่มการดำเนินการใหม่ใน Tree
ชื่อ isEmpty
หากคุณจัดกลุ่มแอปพลิเคชันของคุณโดยการแยกฟังก์ชันและประเภทข้อมูล การสร้าง isEmpty
function นั้นค่อนข้างตรงไปตรงมา
ในทางกลับกัน หากเราใช้แอปพลิเคชันของเราในลักษณะเชิงวัตถุ เราจำเป็นต้องผ่านไฟล์ทั้งหมดในแอปพลิเคชันของเรา และใช้ฟังก์ชัน isEmpty
เนื่องจากเราเปลี่ยนอินเทอร์เฟซของเรา
นี่เป็นปัญหาใน Java หากเรามีมรดกที่ซ้อนกันหลายรายการ เราจำเป็นต้องเปลี่ยนคลาสทั้งหมดที่ใช้อินเทอร์เฟซ
ในกรณีนี้ การเปลี่ยนแปลงเพื่อเพิ่มการดำเนินการใหม่ในวิธีที่เป็นประโยชน์ในการจัดโครงสร้างรหัสแอปพลิเคชันของคุณอยู่ในเครื่อง อย่างไรก็ตาม ด้วยวิธีเชิงวัตถุในการจัดโครงสร้างแอปพลิเคชันของคุณ การเพิ่มกระบวนการใหม่จะเปลี่ยนโครงสร้างแอปพลิเคชันอย่างมาก
เราเรียนรู้อะไรที่นี่?
จัดโครงสร้างโมเดลข้อมูลของคุณอย่างชาญฉลาด! เราไม่มีทางรู้อนาคตของแอปพลิเคชันที่เรากำลังสร้างอยู่ ดังนั้นความยืดหยุ่นจึงเป็นสิ่งสำคัญ
การออกแบบซอฟต์แวร์เป็นศิลปะบางส่วนและเป็นด้านเทคนิคบางส่วน ดังนั้นนักพัฒนาแต่ละรายจะมีรูปแบบการจัดโครงสร้างแอปพลิเคชันของตนเอง
มีหัวข้อทั่วทั้งเว็บเกี่ยวกับแนวทางปฏิบัติที่ดีที่สุดในการจัดโครงสร้างโค้ดของคุณคืออะไร อย่างไรก็ตาม ฉันคิดว่าวิธีที่ดีที่สุดขึ้นอยู่กับแอปพลิเคชันปัจจุบันและตรรกะทางธุรกิจของคุณ
หากคุณรู้ว่าประเภทข้อมูลของคุณจะเปลี่ยนแปลงอยู่เรื่อยๆ ในอนาคต บางทีการสร้างค่าในลักษณะเชิงวัตถุอาจมีความยืดหยุ่นมากขึ้น หากคุณทราบว่าประเภทข้อมูลของคุณมักจะเหมือนเดิม การจัดโครงสร้างโมเดลข้อมูลเชิงฟังก์ชันจะเป็นประโยชน์ต่ออนาคต เนื่องจากฟังก์ชันใหม่จะถูกเพิ่มเข้ามามากกว่าประเภทข้อมูลใหม่
ขอบคุณที่อ่าน! หากคุณชอบโพสต์นี้ คุณสามารถติดตามได้ใน "สื่อ" เพื่อดูโพสต์ประเภทนี้เพิ่มเติม
เผยแพร่ครั้งแรกที่ https://edward-huang.com.