Skip to Content

การห่อหุ้ม (Encapsulation)

วันนี้เรามาเรียนรู้เกี่ยวกับการห่อหุ้ม หรือ Encapsulation ซึ่งเป็นหลักการสำคัญอีกข้อหนึ่งของการเขียนโปรแกรมเชิงวัตถุ (OOP) กัน

การห่อหุ้มคืออะไร?

การห่อหุ้ม คือ การซ่อนรายละเอียดการทำงานภายในของคลาสและเปิดเผยเฉพาะส่วนที่จำเป็นต่อการใช้งานเท่านั้น เปรียบเสมือนการห่อของขวัญ 🎁 คุณเห็นแต่กล่องด้านนอก แต่ไม่รู้ว่าข้างในมีอะไร จนกว่าจะเปิดดู

ทำไมการห่อหุ้มถึงสำคัญ?

  1. ปกป้องข้อมูล: ป้องกันการเข้าถึงข้อมูลโดยตรงจากภายนอก
  2. ควบคุมการเข้าถึง: กำหนดวิธีการเข้าถึงและแก้ไขข้อมูลได้
  3. ยืดหยุ่น: สามารถเปลี่ยนแปลงการทำงานภายในโดยไม่กระทบภายนอก
  4. ลดความซับซ้อน: ซ่อนรายละเอียดที่ไม่จำเป็นจากผู้ใช้

วิธีการสร้างการห่อหุ้ม

การห่อหุ้มทำได้โดยใช้:

  1. Access Modifiers (private, public, protected)
  2. Getter และ Setter methods

มาดูตัวอย่างกัน:

public class บัญชีธนาคาร { private String ชื่อเจ้าของบัญชี; private double ยอดเงิน; // Constructor public บัญชีธนาคาร(String ชื่อเจ้าของบัญชี, double ยอดเงินเริ่มต้น) { this.ชื่อเจ้าของบัญชี = ชื่อเจ้าของบัญชี; this.ยอดเงิน = ยอดเงินเริ่มต้น; } // Getter methods public String getชื่อเจ้าของบัญชี() { return ชื่อเจ้าของบัญชี; } public double getยอดเงิน() { return ยอดเงิน; } // Setter method (เฉพาะชื่อเจ้าของบัญชี) public void setชื่อเจ้าของบัญชี(String ชื่อใหม่) { this.ชื่อเจ้าของบัญชี = ชื่อใหม่; } // Method สำหรับฝากเงิน public void ฝากเงิน(double จำนวนเงิน) { if (จำนวนเงิน > 0) { this.ยอดเงิน += จำนวนเงิน; System.out.println("ฝากเงินสำเร็จ " + จำนวนเงิน + " บาท"); } else { System.out.println("จำนวนเงินไม่ถูกต้อง"); } } // Method สำหรับถอนเงิน public void ถอนเงิน(double จำนวนเงิน) { if (จำนวนเงิน > 0 && จำนวนเงิน <= this.ยอดเงิน) { this.ยอดเงิน -= จำนวนเงิน; System.out.println("ถอนเงินสำเร็จ " + จำนวนเงิน + " บาท"); } else { System.out.println("จำนวนเงินไม่ถูกต้องหรือยอดเงินไม่พอ"); } } }

ในตัวอย่างนี้:

  • ชื่อเจ้าของบัญชี และ ยอดเงิน เป็น private ไม่สามารถเข้าถึงโดยตรงจากภายนอกได้
  • เราใช้ getter methods เพื่อดูข้อมูล
  • เราใช้ setter method สำหรับเปลี่ยนชื่อเจ้าของบัญชี
  • การฝากและถอนเงินทำผ่าน methods ที่มีการตรวจสอบความถูกต้อง

การใช้งานคลาสที่มีการห่อหุ้ม

public class ทดสอบบัญชีธนาคาร { public static void main(String[] args) { บัญชีธนาคาร บัญชีของฉัน = new บัญชีธนาคาร("สมชาย", 1000); System.out.println("ชื่อเจ้าของบัญชี: " + บัญชีของฉัน.getชื่อเจ้าของบัญชี()); System.out.println("ยอดเงินปัจจุบัน: " + บัญชีของฉัน.getยอดเงิน()); บัญชีของฉัน.ฝากเงิน(500); บัญชีของฉัน.ถอนเงิน(200); System.out.println("ยอดเงินหลังทำรายการ: " + บัญชีของฉัน.getยอดเงิน()); // ไม่สามารถเข้าถึงหรือแก้ไข ยอดเงิน โดยตรงได้ // บัญชีของฉัน.ยอดเงิน = 1000000; // จะเกิด error // แต่สามารถเปลี่ยนชื่อเจ้าของบัญชีได้ผ่าน setter บัญชีของฉัน.setชื่อเจ้าของบัญชี("สมหญิง"); System.out.println("ชื่อเจ้าของบัญชีใหม่: " + บัญชีของฉัน.getชื่อเจ้าของบัญชี()); } }

ประโยชน์ของการห่อหุ้ม

  1. ความปลอดภัยของข้อมูล: ป้องกันการเข้าถึงและแก้ไขข้อมูลโดยไม่ได้รับอนุญาต
  2. การควบคุมการเข้าถึง: สามารถกำหนดว่าข้อมูลใดสามารถอ่านหรือแก้ไขได้
  3. ความยืดหยุ่น: สามารถเปลี่ยนแปลงการทำงานภายในโดยไม่กระทบต่อโค้ดภายนอก
  4. การบำรุงรักษา: ทำให้โค้ดเป็นระเบียบและง่ายต่อการบำรุงรักษา

เทคนิคเพิ่มเติมในการใช้การห่อหุ้ม

  1. Immutable Objects: สร้างวัตถุที่ไม่สามารถเปลี่ยนแปลงค่าได้หลังจากสร้าง
  2. Validation: ตรวจสอบความถูกต้องของข้อมูลก่อนที่จะกำหนดค่า
  3. Lazy Initialization: สร้างหรือคำนวณค่าเมื่อมีการเรียกใช้ครั้งแรกเท่านั้น

สรุป

การห่อหุ้มเป็นหลักการสำคัญใน OOP ที่ช่วยให้เราสร้างโค้ดที่ปลอดภัย ยืดหยุ่น และบำรุงรักษาได้ง่าย โดยการซ่อนรายละเอียดการทำงานภายในและควบคุมการเข้าถึงข้อมูล การใช้การห่อหุ้มอย่างเหมาะสมจะช่วยให้คุณสามารถออกแบบและเขียนโปรแกรมที่มีคุณภาพสูงขึ้น

ปรับปรุงล่าสุด