การใช้งาน Polymorphism ใน OOP Concept ในภาษา Fortran

การเขียนโปรแกรมที่มีประสิทธิภาพและใช้งานง่ายนั้น มักจะต้องอาศัยแนวคิดหลักของการเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming: OOP) หนึ่งในแนวคิดที่น่าสนใจคือ "Polymorphism" ซึ่งแปลว่า "หลายรูปแบบ" นั่นเอง ในบทความนี้ เราจะมาทำความเข้าใจเกี่ยวกับการใช้งาน Polymorphism ในภาษา Fortran กันอย่างละเอียด พร้อมตัวอย่างโค้ดและการใช้งานจริง

Polymorphism คืออะไร?

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

Polymorphism ในภาษา Fortran

ถึงแม้ว่า Fortran จะไม่เป็นภาษาที่โดดเด่นใน OOP แต่ในเวอร์ชันล่าสุดเช่น Fortran 2003 และ Fortran 2008 ก็ได้มีการสนับสนุนการเขียนโปรแกรมเชิงวัตถุเช่นกัน เราสามารถใช้ polymorphism ใน Fortran ได้โดยการใช้การสืบทอดและหน้า interface

ตัวอย่างการใช้งาน Polymorphism ใน Fortran

ในตัวอย่างนี้ เราจะดูการสร้างคลาสสองคลาสที่มีเมธอดเดียวกัน แต่ทำงานแตกต่างกัน และใช้ interface ในการกำหนด polymorphism

 module animals
    implicit none

    type, abstract :: animal
    contains
        procedure, abstract :: makeSound
    end type animal

    type, extends(animal) :: dog
    contains
        procedure :: makeSound => dogMakeSound
    end type dog

    type, extends(animal) :: cat
    contains
        procedure :: makeSound => catMakeSound
    end type cat

contains

    subroutine dogMakeSound(this)
        class(dog), intent(in) :: this
        print *, "Woof!"
    end subroutine dogMakeSound

    subroutine catMakeSound(this)
        class(cat), intent(in) :: this
        print *, "Meow!"
    end subroutine catMakeSound

end module animals

program main
    use animals
    implicit none

    class(animal), allocatable :: pet

    ! สร้างสุนัข
    allocate(dog :: pet)
    call pet%makeSound()  ! Output: Woof!

    ! สร้างแมว
    allocate(cat :: pet)
    call pet%makeSound()  ! Output: Meow!
end program main

อธิบายการทำงาน

ในตัวอย่างโค้ดข้างต้น เราได้สร้างโมดูลที่ชื่อว่า `animals` ซึ่งประกอบด้วยอ็อบเจ็กต์ที่เกี่ยวข้องกับสัตว์ โดยมีสองชนิดคือ `dog` และ `cat` ทั้งสองชนิดนี้สืบทอดมาจากชนิด `animal` ซึ่งเป็นชนิด abstract หมายความว่าเราไม่สามารถสร้างอ็อบเจ็กต์จากมันได้โดยตรง แต่เราสามารถสร้างอ็อบเจ็กต์จากชนิดที่สืบทอดมาจากมัน

เมื่อเราสร้างโครงการหลัก เราสามารถกำหนดตัวแปร `pet` ที่มีประเภทเป็น `animal` และทำการ allocate ให้มันเป็น `dog` หรือ `cat` ได้ เมื่อเราเรียกใช้ `makeSound` มันจะเรียกใช้ฟังก์ชันที่ถูก override ในแต่ละคลาส ทำให้เราสามารถจัดการกับทั้งสองประเภทโดยใช้ interface เดียวกัน

Use Case ในโลกจริง

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

สรุป

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

หากคุณสนใจในการเรียนรู้การเขียนโปรแกรม โดยเฉพาะในแนวคิด OOP รวมถึงการใช้งานในภาษา Fortran ตลอดจนภาษาคอมพิวเตอร์อื่น ๆ อย่าลืมมาศึกษากับเราที่ EPT (Expert-Programming-Tutor) นะครับ เรามีหลักสูตรดี ๆ บรรยากาศการเรียนที่เป็นกันเอง และทีมงานผู้สอนที่มีประสบการณ์ รอให้คุณมาเป็นส่วนหนึ่งในการพัฒนาทักษะการเขียนโปรแกรมของคุณ!

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