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

ประเภทข้อมูลพีชคณิตมีทั้งข้อดีและข้อเสีย ช่วยให้คุณสามารถเขียนแอปพลิเคชันของคุณในลักษณะที่ปลอดภัยต่อการพิมพ์ — เมื่อคุณทำการจับคู่รูปแบบ จะทำให้ประเภทข้อมูลทั้งหมดหมดสำหรับคุณ อย่างไรก็ตาม การใช้ 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

หากคุณจัดกลุ่มแอปพลิเคชันของคุณโดยการแยกฟังก์ชันและประเภทข้อมูล การสร้าง isEmptyfunction นั้นค่อนข้างตรงไปตรงมา

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

นี่เป็นปัญหาใน Java หากเรามีมรดกที่ซ้อนกันหลายรายการ เราจำเป็นต้องเปลี่ยนคลาสทั้งหมดที่ใช้อินเทอร์เฟซ

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

เราเรียนรู้อะไรที่นี่?

จัดโครงสร้างโมเดลข้อมูลของคุณอย่างชาญฉลาด! เราไม่มีทางรู้อนาคตของแอปพลิเคชันที่เรากำลังสร้างอยู่ ดังนั้นความยืดหยุ่นจึงเป็นสิ่งสำคัญ

การออกแบบซอฟต์แวร์เป็นศิลปะบางส่วนและเป็นด้านเทคนิคบางส่วน ดังนั้นนักพัฒนาแต่ละรายจะมีรูปแบบการจัดโครงสร้างแอปพลิเคชันของตนเอง

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

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

ขอบคุณที่อ่าน! หากคุณชอบโพสต์นี้ คุณสามารถติดตามได้ใน "สื่อ" เพื่อดูโพสต์ประเภทนี้เพิ่มเติม

เผยแพร่ครั้งแรกที่ https://edward-huang.com.