Encapsulation

ในบทเรียนนี้ เราจะพูดเกี่ยวกับ encapsulation (คุณสมบัติการห่อหุ้ม) ในภาษา Java และอธิบายแนวคิดในการนำไปใช้งานและพัฒนาโปรแกรม

Encapsulation คืออะไร

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

แนวคิดของ Encapsulation ที่มีตัวแปรที่ถูกปกปิดไว้ภายใน

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

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

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

ต่อไปมาดูตัวอย่างการพัฒนาโปรแกรมที่มีคุณสมบัติในการปกปิดข้อมูล ซึ่งเป็นโปรแกรมนาฬิกานับเวลา

// TestTimer.java
public class TestTimer {
    public static void main (String[] args) {
        Timer time = new Timer();
        time.setTime(9, 30, 55);

        while (true) {
            time.increaseTime();
            System.out.println(time.getTime());

            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        }
    }
}

class Timer {
    public int timeStamp = 0;

    private int second = 0;
    private int minute = 0;
    private int hour = 0;

    public void setTime(int h, int m, int s) {
        second = s; minute = m; hour = h;
        timeStamp = (hour * 3600) + (minute * 60) + second;
    }

    public void increaseTime() {
        timeStamp = (timeStamp + 1) % 86400;
        updateMembers ();
    }

    private void updateMembers () {
        second = timeStamp % 60;
        minute = (timeStamp / 60) % 60;
        hour = (timeStamp / 3600) % 24;
    }

    public String getTime() {
        return String.format("%02d:", hour) + 
               String.format("%02d:", minute) + 
               String.format("%02d", second);
    } 
}

ในตัวอย่างเป็นโปรแกรมแสดงนาฬิกาเหมือนในคอมพิวเตอร์ของเรา เราได้สร้างคลาส Timer ซึ่งเป็นคลาสของนาฬิกา และภายในจะมีสมาชิกตัวแปรที่เป็น private ได้แก่ second minute hour และสมาชิกเมธอด updateMembers () นั่นหมายความว่าข้อมูลเหล่านี้ถูกห่อหุ้ม เราไม่สามารถเข้าถึงมันได้โดยตรง

ทางเดียวที่เราสามารถทำได้คือเข้าถึงข้อมูลโดยเมธอดหรือตัวแปรที่เป็น public ในคำสั่ง

time.increaseTime();

เป็นการเพิ่มเวลาขึ้นไป 1 วินาที เราทราบว่าเมื่อเมธอดนี้ทำงานเวลาจะเพิ่มขึ้นไป 1 วินาที แต่ภายในการทำงานของมันว่าเป็นยังไง เราไม่ได้ทราบ และคำสั่งต่อไป

System.out.println(time.getTime());

เช่นเดียวกัน เราทราบว่าเมธอดนี้จะส่งค่าเวลากลับมาให้เรา และเราไม่ทราบว่ามันส่งข้อมูลมาแบบไหน หรือประเภทข้อมูลที่เก็บนั้นเป็นแบบใด สิ่งเหล่านี้เองเราเรียกกว่า **Encapsulation **

try {
    Thread.sleep(1000);
} catch (InterruptedException ex) {
    System.out.println(ex);
}

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

09:30:56
09:30:57
09:30:58
09:30:59
09:31:00
09:31:01
09:31:02
09:31:03
09:31:04
09:31:05
.
.
.

และนี่เป็นผลลัพธ์ของโปรแกรม มันจะนับเวลาและแสดงเวลาไปเรื่อยๆ เพราะเราให้ infinity loop คุณต้องออกจากโปรแกรมเพื่อจบมัน

ในความจริง encapsulation นั้นมีอยู่รอบตัวหรือคุณใช้มันมาแล้ว เช่น เมธอด println() ซึ่งมีเบื้องหลังการทำงานที่จะต้องทำการติดต่อกับจอภาพ และอื่นๆ อีกมากมาย แต่เราใช้มันแค่เพียงคำสั่งเดียวและได้ผลลัพธ์ออกมา หรือแม้กระทั่งคุณขับรถยนต์แล้วเปลี่ยนเกียร์ ซึ่งมีกลไกลต่างๆ ที่เกิดขึ้นมากกว่าที่คุณเห็นบนหน้าปัด แต่มันถูกปกปิดไว้

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