การใช้งาน accesibility in OOP concept ในภาษา fortran แบบง่ายๆ พร้อมตัวอย่าง CODE 3 ตัวอย่าง และอธิบายการทำงาน และยกตัวอย่าง usecase ในโลกจริง

ด้วยความพิเศษของการเขียนโปรแกรมที่ท้าทายไปด้วยความสร้างสรรค์ วันนี้เราจะทะลุผ่านมิติของการใช้งานความสามารถพิเศษในการเขียนโปรแกรมแนววัตถุ (Object-Oriented Programming - OOP) กับภาษา Fortran ที่เราอาจจะคุ้นเคยในฐานะภาษาโปรแกรมมิ่งของวงการวิทยาศาสตร์และวิศวกรรม น่าจะสนุกนะครับ ถ้าเราจะได้จับต้องกับตัวอย่างการเขียนโค้ดที่ชวนให้หัวใจเต้นตึกตักกับ "accessibility in OOP concept" หรือ ความสามารถในการเข้าถึงของสมาชิกในวัตถุในแบบฉบับที่เข้าใจง่ายๆ และรอบคอบด้วยวิจารณญาณ

ก่อนอื่น มาทำความเข้าใจเกี่ยวกับ OOP ใน Fortran กันเสียหน่อย ในตัวภาษา Fortran โดยเฉพาะในเวอร์ชั่นที่สดใหม่อย่าง Fortran 90 ไปจนถึง Fortran 2003 ขึ้นไปนั้น เพิ่มความสามารถของการเขียนโค้ดแบบวัตถุได้ ที่นี่นะครับ เราจะเน้นไปที่การกำหนดระดับความสามารถในการเข้าถึง (accessibility) ได้แก่ public และ private ซึ่งเป็นกลไกพื้นฐานของการควบคุมการเข้าถึงสมาชิกของวัตถุ (อาจเป็นตัวแปรหรือฟังก์ชั่น) ซึ่งทำให้โค้ดของเราเป็นไปอย่างเป็นระบบและปลอดภัยมากยิ่งขึ้น

เรามากับตัวอย่างโค้ดกันเลยดีกว่าครับ อย่าลืมนะครับว่า Fortran ในโลกปัจจุบันนั้นใช้โมดูล (module) ในการจัดการ OOP ได้อย่างมีระดับและความรู้สึกที่ราบรื่น

ตัวอย่างโค้ดที่ 1: คลาสสัตว์ (Animal) พร้อมสมาชิกที่เป็น public และ private

module animal_module
  implicit none
  type, public :: Animal
    character(len=20) :: name
    private
    integer :: age
  contains
    procedure, public :: setAge
    procedure, public :: getAge
  end type Animal

contains

  subroutine setAge(this, newAge)
    class(Animal), intent(inout) :: this
    integer, intent(in) :: newAge
    this%age = newAge
  end subroutine setAge

  function getAge(this) result(age)
    class(Animal), intent(in) :: this
    integer :: age
    age = this%age
  end function getAge

end module animal_module

ในโค้ดนี้, เราสร้าง type ที่ชื่อว่า Animal ซึ่งมีสมาชิกคือ `name` และ `age` ที่เป็นส่วนตัว (private) ทำให้ไม่สามารถเข้าถึง `age` ได้โดยตรงจากตัวแปรที่เป็น instance ของ `Animal`. แต่เราสร้างฟังก์ชั่น `setAge` และ `getAge` เพื่อเข้าถึงข้อมูลนั้นในทางอ้อม

ตัวอย่างโค้ดที่ 2: ใช้งานสมาชิก private ใน main program

program test_animal
  use animal_module
  implicit none
  type(Animal) :: myPet
  call myPet%setAge(5) ! Set age without directly accessing the private variable
  print *, 'My pet is ', myPet%getAge(), ' years old.'
end program test_animal

ตัวอย่างโค้ดนี้เป็นตัวโปรแกรมหลักที่เราสร้าง object `myPet` ขึ้นมาจากคลาส `Animal` และทำการกำหนดอายุผ่าน `setAge` ซึ่งเป็นประตูทางเข้าถึง `age` ที่ถูกปกป้องด้วย private access modifier.

ตัวอย่างโค้ดที่ 3: ฟังก์ชั่นที่เข้าถึง private member ของคลาสอื่น

module utilities_module
  use animal_module
  implicit none
contains
  subroutine printAnimalAge(animal)
    type(Animal), intent(in) :: animal
    print *, 'The animal age is ', animal%getAge()
  end subroutine printAnimalAge
end module utilities_module

ในตัวอย่างนี้เรามีโมดูล `utilities_module` ที่ใช้ `animal_module` ประกอบการทำงาน โดยฟังก์ชั่น `printAnimalAge` จะรับผ่าน object จากคลาส `Animal` และจัดพิมพ์อายุของสัตว์ โดยใช้ `getAge` ที่เป็น public method ซึ่งสามารถเข้าถึง private member `age` ได้.

Usecase ในโลกจริง

การใช้งาน OOP พร้อมกับ concept ของ accessibility นี้สามารถนำไปใช้ในงานที่ต้องการความปลอดภัยและระเบียบเช่นการพัฒนาซอฟต์แวร์ที่จัดการข้อมูลสำคัญในธนาคาร, ระบบจัดการข้อมูลโรงพยาบาล หรือแม้กระทั่งซอฟต์แวร์ที่ใช้งานภายในห้องปฏิบัติการวิจัย เพื่อป้องกันการเข้าถึงหรือการแก้ไขข้อมูลที่ไม่ได้รับอนุญาต

มาลองแตะต้องการเรียนรู้และพัฒนาโปรแกรมมิ่งกับเราที่ EPT ได้นะครับ ที่นี่เรารวมพลคนรักการเขียนโค้ดและพร้อมแบ่งปันความรู้และประสบการณ์ในการพัฒนาทักษะการเขียนโปรแกรมเพื่อรับมือกับปัญหาและโอกาสในอนาคต ไม่ว่าจะเป็น Fortran หรือภาษาอื่นๆ ให้ทุกการเรียนรู้เป็นไปอย่างมีประสิทธิผลและน่าตื่นเต้นไปกับเราครับ!

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