การใช้งาน Encapsulation ใน OOP Concept ในภาษา Julia

การเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming: OOP) เป็นแนวทางหนึ่งที่ช่วยให้เราสามารถจัดการกับซอฟต์แวร์ขนาดใหญ่ได้อย่างมีระเบียบ โดยมีหลักการสำคัญที่เรียกว่า Encapsulation ซึ่งหมายถึงการรวมข้อมูลและฟังก์ชันเข้าด้วยกันในรูปแบบของคลาส และการซ่อนข้อมูลที่ไม่ต้องการให้ผู้ใช้เข้าถึงโดยตรง ในบทความนี้ เราจะมาดูการใช้งาน Encapsulation ในภาษา Julia แบบง่ายๆ พร้อมตัวอย่างโค้ดและการอธิบายการทำงานของมัน รวมถึงตัวอย่างการใช้ในโลกจริง

Encapsulation คืออะไร?

Encapsulation หรือการห่อหุ้ม ข้อดีหลักๆ คือการแยกข้อมูลและฟังก์ชันออกจากกัน ซึ่งช่วยในการรักษาความปลอดภัยให้กับข้อมูล ลดความซับซ้อน และทำให้การดูแลรักษาโค้ดทำได้ง่ายขึ้น ทุกสิ่งทุกอย่างใน OOP จะถูกจัดระเบียบในรูปแบบของคลาส (Class) ซึ่งภายในคลาสสามารถมีพวก properties (ข้อมูล) และ methods (ฟังก์ชัน) ที่ทำงานเกี่ยวข้องกันได้

หลักการทำงาน

ในภาษา Julia เราสามารถสร้างคลาสขึ้นมาได้โดยใช้ `struct` ซึ่งเป็นคำสั่งสำหรับสร้างโครงสร้างข้อมูล เช่นเดียวกับการสร้างคลาสในภาษาอื่นๆ โดยเราสามารถกำหนด visibility ให้กับชิ้นส่วนของข้อมูลภายในคลาส เช่น private และ public

ตัวอย่างโค้ด

มาดูโค้ดตัวอย่างที่แสดงให้เห็นถึงการใช้งาน Encapsulation:

 # สร้างคลาสที่เรียกว่า Account
struct Account
    # ข้อมูล private
    private_balance::Float64

    function Account(initial_balance::Float64)
        # สร้าง Account ใหม่ด้วยยอดเงินเริ่มต้น
        new(initial_balance)
    end

    # ฟังก์ชันเพื่อดูยอดเงิน
    function get_balance(account::Account)
        return account.private_balance
    end

    # ฟังก์ชันในการฝากเงิน
    function deposit!(account::Account, amount::Float64)
        account.private_balance += amount
    end

    # ฟังก์ชันในการถอนเงิน
    function withdraw!(account::Account, amount::Float64)
        if amount > account.private_balance
            throw(ArgumentError("Not enough balance"))
        else
            account.private_balance -= amount
        end
    end
end

# การสร้าง instance ของ Account
my_account = Account(1000.0)

# ดูยอดเงิน
println("ยอดเงินในบัญชี: ", get_balance(my_account))

# ฝากเงิน
deposit!(my_account, 500.0)
println("ยอดเงินหลังการฝาก: ", get_balance(my_account))

# ถอนเงิน
withdraw!(my_account, 300.0)
println("ยอดเงินหลังการถอน: ", get_balance(my_account))

การอธิบายโค้ด

ในตัวอย่างข้างต้น เราได้สร้างคลาส `Account` ที่ใช้ `struct` ในการจัดเก็บข้อมูลยอดเงินของบัญชี ซึ่งเราได้ตั้งเป็น private เพื่อไม่ให้สามารถเข้าถึงโดยตรงจากภายนอกคลาส เรามีฟังก์ชัน `get_balance`, `deposit!` และ `withdraw!` เพื่อให้ผู้ใช้สามารถดูยอดเงิน, ฝากเงิน และถอนเงินจากบัญชีได้

- `get_balance`: ฟังก์ชันนี้ใช้เพื่อดึงยอดเงินในบัญชี ตรวจสอบได้ว่าเงินในบัญชีเป็นเท่าไหร่

- `deposit!`: ฟังก์ชันนี้ใช้เพื่อเพิ่มยอดเงินเข้าบัญชี

- `withdraw!`: ฟังก์ชันนี้จะทำการหักเงินออกจากบัญชี และมีการตรวจสอบเงื่อนไขเพื่อให้แน่ใจว่าไม่สามารถถอนเงินมากกว่ ยอดเงินที่มีได้

ตัวอย่าง Use Case ในโลกจริง

สรุป

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

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

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