# การใช้งาน OOP ในภาษา Fortran: ความเข้าใจและประยุกต์ใช้งานในโลกแห่งการพัฒนาแบบมืออาชีพ
สวัสดีผู้อ่านทุกท่าน! ในวงการการเขียนโปรแกรมปัจจุบัน หลักการ Object-Oriented Programming (OOP) นับเป็นหนึ่งในหลักการพื้นฐานที่จำเป็นต่อนักพัฒนาโปรแกรมทุกคน เพราะมันช่วยให้การเขียนโค้ดเป็นไปได้ด้วยความเรียบง่าย มีระเบียบ และง่ายต่อการบำรุงรักษา แม้ว่าหลายคนจะคุ้นเคยกับ OOP ในภาษาสมัยใหม่อย่าง Java, C++, หรือ Python แต่คุณรู้หรือไม่ว่าการใช้งาน OOP ในภาษา Fortran ก็เป็นไปได้และมีความมีประสิทธิภาพเช่นกัน
Fortran เป็นหนึ่งในภาษาโปรแกรมที่เก่าแก่ที่สุด แต่ด้วยการพัฒนาอย่างต่อเนื่อง มันได้รวมหลักการ OOP ไว้ภายในมาตรฐานภาษาตั้งแต่ Fortran 2003 นอกเหนือจากความสามารถในการจัดการกับงานทางวิทยาศาสตร์และวิศวกรรมได้ดีอยู่แล้ว การเพิ่ม OOP เข้าไปทำให้ Fortran เป็นภาษาที่เหมาะสมอย่างยิ่งสำหรับการสร้างโปรแกรมที่มีโครงสร้างซับซ้อน
ตัวอย่างที่ 1: การสร้าง Class พื้นฐานใน Fortran
Fortran ใช้คำว่า 'type' แทน 'class' ในภาษาอื่น ๆ ลองมาดูตัวอย่างของการสร้าง class สำหรับจัดการกับวันที่:
module date_mod
implicit none
type :: date_t
integer :: day
integer :: month
integer :: year
end type date_t
end module date_mod
program test_date
use date_mod
type(date_t) :: today
today%day = 13
today%month = 4
today%year = 2023
print *, "Today's date is", today%day, today%month, today%year
end program test_date
ในตัวอย่างนี้ เราสร้าง module ที่มีการนิยาม type `date_t` ซึ่งประกอบด้วย day, month, และ year เป็น integers และเราสามารถใช้งาน type นี้ในโปรแกรมหลักของเราเพื่อแสดงวันที่
ตัวอย่างที่ 2: การใช้งาน Methods และ Encapsulation
ใน OOP, encapsulation เป็นหลักการที่ข้อมูลภายใน object ถูกซ่อนไว้จากการเข้าถึงโดยตรงจากนอก object และการจัดการข้อมูลนั้นทำผ่าน methods. ใน Fortran, คุณสามารถสร้าง procedures ภายใน module เพื่อใช้เป็น methods.
module math_mod
implicit none
type :: vector_t
real :: x
real :: y
contains
procedure :: add => add_vectors
end type vector_t
contains
function add_vectors(this, other) result(new_vector)
class(vector_t), intent(in) :: this
class(vector_t), intent(in) :: other
type(vector_t) :: new_vector
new_vector%x = this%x + other%x
new_vector%y = this%y + other%y
end function add_vectors
end module math_mod
program test_vector
use math_mod
type(vector_t) :: v1, v2, v3
v1%x = 3.0
v1%y = 4.0
v2%x = 5.0
v2%y = 6.0
v3 = v1%add(v2)
print *, "v3 x:", v3%x, "y:", v3%y
end program test_vector
ในที่นี้ `vector_t` มี method `add` ที่ใช้ในการรวมสอง vectors เข้าด้วยกัน ผลลัพธ์จาก method นี้คือ vector ใหม่ที่มีค่า x และ y เป็นผลรวมของทั้งสอง vector.
ตัวอย่างที่ 3: การใช้งาน Inheritance
การสืบทอดหรือ inheritance ช่วยให้สามารถสร้าง class ที่เป็น 'ลูก' ของ class อื่น โดยมีการสืบทอดคุณสมบัติไปโดยปริยาย Fortran จัดการกับการสืบทอดผ่านทางการใช้ `extends`.
module shape_mod
implicit none
type :: shape_t
real :: area
contains
procedure :: compute_area => shape_compute_area
end type shape_t
type, extends(shape_t) :: square_t
real :: side_length
contains
procedure :: compute_area => square_compute_area
end type square_t
end module shape_mod
module procedures
use shape_mod
contains
function shape_compute_area(this) result(area)
class(shape_t), intent(in) :: this
real :: area
! Assume some generic computatilon for area:
area = 0.0
end function shape_compute_area
function square_compute_area(this) result(area)
class(square_t), intent(in) :: this
real :: area
area = this%side_length**2
end function square_compute_area
end module procedures
program test_square
use shape_mod
type(square_t) :: s1
s1%side_length = 5.0
s1%compute_area()
print *, "Area of square is:", s1%area
end program test_square
ในตัวอย่างนี้ เรามี class ประเภท `shape_t` และ `square_t` เป็น subclass ของ `shape_t`. เมื่อเราเรียก `compute_area()` บน object ของ `square_t`, มันจะเรียกใช้ method `square_compute_area` ที่จะคำนวณพื้นที่ของสี่เหลี่ยมจัตุรัส.
Usecase ของ OOP ใน Fortran ในโลกจริง
Fortran มีแนวโน้มที่จะถูกใช้งานอย่างกว้างขวางในงานทางด้านการคำนวณวิทยาศาสตร์สูง เช่น วิทยาวจัยทางด้านฟิสิกส์ของฟลุคส์ในดวงอาทิตย์, การจำลองสภาพอากาศ, หรือการคำนวณความเร็วและการควบคุมของอากาศยาน เนื่องจากหลักการ OOP เสนอการออกแบบที่ช่วยในการจัดระเบียบข้อมูลและโค้ดได้อย่างมีระบบ อีกทั้งยังช่วยทำให้โค้ดสามารถนำกลับมาใช้ใหม่ (reusability) และขยายทำนอง (extensibility) ทำให้เหมาะอย่างยิ่งสำหรับการพัฒนาโปรแกรมทางวิทยาศาสตร์ที่มีความซับซ้อน
จากการเรียนรู้ข้างต้น คุณคงเห็นแล้วว่าภาษา Fortran ไม่ได้เก่าแก่เสมอไป เมื่อเจาะลึกเข้าไป เราพบว่าหลักการ OOP ใน Fortran ส่งผลให้การพัฒนาโปรแกรมมีความยืดหยุ่นมากขึ้นและช่วยให้เราสามารถแก้ปัญหาได้ในมุมที่หลากหลาย ณ จุดนี้ หากคุณอยากรู้จักและเข้าใจภาษา Fortran และหลักการ OOP อย่างลึกซึ้งยิ่งขึ้น ที่ EPT หรือ Expert-Programming-Tutor ก็พร้อมที่จะเป็นที่พึ่งให้กับทุกคน ด้วยหลักสูตรการเขียนโปรแกรมที่ทันสมัย คุณจะเชี่ยวชาญเครื่องมือนี้และนำไปประยุกต์ใช้ในการทำงานของคุณได้อย่างเชี่ยวชาญ มาเรียนรู้และเติบโตทางด้านการเขียนโปรแกรมไปด้วยกันที่ EPT เพื่อก้าวไปสู่เป้าหมายในการเป็นนักพัฒนาซอฟต์แวร์ระดับมืออาชีพกันเถอะ!
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM