การ ห อ ห ม ข อม ล encapsulation java

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

1. การห่อหุ้ม

Encapsulation ใน java และเป็นหนึ่งในเสาหลักของการเขียนโปรแกรมเชิงวัตถุที่สร้างความเป็นไปได้ในการซ่อนข้อมูลคุณสมบัติของวัตถุเพื่อไม่ให้เข้าถึงโดยตรง

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

1.1. การปกปิดข้อมูล

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

2. ตัวอย่าง

เพื่อให้เข้าใจแนวคิดเหล่านี้ ให้เราพิจารณาคลาส Tiempo.

class Tiempo {
    //////////////////////////
    // Atributos
    //////////////////////////
    private int hora;
    private int minutos;
    //////////////////////////
    // Métodos
    //////////////////////////
    public int getHora() {
        return hora;
    }
    public void setHora(int hora) {
        hora = this.hora;
    }
    public int getMinutos() {
        return minutos;
    }
    public void setHora(int minutos) {
        minutos = this.minutos();
    }
}

ในคลาสนี้จะเห็นได้ว่าแอตทริบิวต์เป็นแบบส่วนตัวซึ่งบ่งชี้ว่าวัตถุที่เราสร้างจากคลาสดังกล่าวจะไม่สามารถเข้าถึงแอตทริบิวต์ได้โดยตรง วัตถุเหล่านี้แม้ว่าจะมีแอตทริบิวต์ (ชั่วโมงและนาที) จะไม่ สามารถใช้งานได้เนื่องจากความเป็นส่วนตัวสามารถใช้ได้เฉพาะในไฟล์เดียวกันและเฉพาะเจาะจงมากขึ้นในคลาสเดียวกันกับที่มีการประกาศ

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

Tiempo t = new Tiempo();
t.setHora(20);
t.hora = 40;

2.2. การเปรียบเทียบส่วนตัวและสาธารณะ

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

3. ยูทิลิตี้การห่อหุ้ม

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

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

วันก่อนไปคุยในงาน HackerX มา แล้วมีบริษัทหนึ่งถามให้อธิบายว่า OOP (Object-Oriented Programming) หรือ การเขียนโปรแกรมเชิงวัตถุคืออะไร? ผมก็เลยอยากมาเขียนทบทวนความรู้เรื่องนี้กันหน่อย และก็จะขยายความ 4 หลักการของ OOP ว่ามีรายละเอียดอย่างไร?

OOP คืออะไร?

แปลตรงๆ ก็คือการเขียนโปรแกรมเชิงวัตถุ เป็นกระบวนทัศน์หรือรูปแบบหนึ่งของการเขียนโปรแกรม (จริงๆ แล้วมีรูปแบบอื่น อย่างเช่น procedural, functional และ symbolic) โดยจะมองทุกอย่างในโปรแกรมหรือแอพพลิเคชันเป็น “วัตถุ” ซึ่งก็เหมือนวัตถุในชีวิตจริงของเรา อย่างเช่น สุนัก, แมว, โทรทัศน์, จักรยาน , โต๊ะ หรือ เก้าอี้

วัตถุในชีวิตจริงจะสังเกตุว่า จะมี “สถานะ (state)” และ “พฤติกรรม (behavior)” อย่างเช่น สุนัก มีสถานะ (ชื่อ, สี, สายพันธุ์) และมีพฤติกรรม (เห่า, กระดิกหาง), จักรยาน มีสถานะ (เกียร์, ปันได, ความเร็ว) และมีพฤติกรรม (เปลี่ยนเกียร์, เปลี่ยนจังหว่ะบันได, เร่งความเร็ว) เป็นต้น

OOP ก็ใช้วิธีเลียนแบบวิธีคิดของวัตถุในชีวิตจริง โดยระบุ “สถานะ” และ “พฤติกรรม” สำหรับวัตถุของซอฟต์แวร์

โดยวัตถุ (Object) จะเก็บสถานะใน ฟิล์ด (field) (ตัวแปลในบางภาษา) และเปิดเผยพฤติกรรมผ่าน เมธอด (method) (ฟังก์ชันในบางภาษา) โดยที่ method จะดำเนินการกับสถานะภายในของ object นั้น และเป็นกลไกหลักในการสื่อสารระหว่าง object กับ object ซึ่งจะมีการซ้อนสถานะภายใน และการติดต่อกับ object ทั้งหมดจำเป็นต้องกระทำผ่าน method ของ object นั้น

ซึ่ง OOP จะมีหลักการที่เป็นเสาหลักอยู่ 4 ข้อ ดังนี้

Abstraction

เป็นหลักการนามธรรมของ object ซึ่งเป็นกระบวนการในการเอาส่วน concrete ของ class หรือส่วนที่มีการ implementation ของ object ออกมา โดยรักษาลักษณะร่วมกัน หรือคุณลักษณะให้กับ concreate object ต่างๆ ซึ่งจะเป็นการใช้หลักการอื่นๆ ของ OOP ในการทำให้เกิด abstaction โดยเฉพาะอย่างยิ่ง Polymorphism และในบางภาษาจะมี abstract/interface keyword มาให้เพื่อระบุ class ที่ต้องการให้มีคุณสมบัติ abstraction ตัวอย่างดังนี้

Encapsulation

เป็นหลักการการห่อหุ้มสถานะหรือข้อมูลของ object จากภายนอกให้ไม่สามารถเข้าถึงสถานะของ object ได้ ดั้งนั้นการเข้าถึงจะต้องกระทำผ่านทาง method เท่านั้น (เรียกว่า setter/getter) ซึ่งการซ้อนข้อมูลก็มีหลายระดับ private จำกัดการเข้าถึงอย่างสิ้นเชิง, protected จำกัดการเข้าถึงจากภายนอกแต่ class ลูกสามารถเข้าถึงได้ หรือ public ไม่จำกัดดารเข้าถึงเลยภายนอกสามารถเข้าถึงได้ เป็นต้น บางภาษาอาจจะมีมากกว่านี้ ตัวอย่างเช่น

Inheritance

เป็นหลักการสืบทอดคุณสมบัติของ object ซึ่ง class (subclass) ที่สืบทอดจาก class อื่น (superclass) จะได้รับสถานะและพฤติกรรมของ class นั้นทั้งหมด และยังสามารถเปลี่ยนพฤติกรรมของบาง method (overriding) ที่ได้สืบทอดมาได้ อีกทั้งสามารถขยายความสามารถเพิ่มเติมได้อีก ทำให้เราสามารถนำโค้ดที่มีอยู่แล้วมาใช้ใหม่ได้ (code reuse) ตัวอย่างเช่น

Polymorphism

เป็นหลักการพ้องรูปหรือการมีหลายรูปของ object คล้ายๆ กับหลักการของชีววิทยาที่สิ่งมีชีวิตสามารถมีหลายรูปแบบ หรือหลายสายพันธุ์ (เช่น มนุษย์ มี มองโกลลอยด์, คอเคซอยด์ หรือนิกรอยด์ เป็นตั้น ซึ่งทั้งหมดก็เป็น มนุษย์ เหมือนกัน) โดย subclass ของ class สามารถกำหนดพฤติกรรมที่เป็นเอกลักษณ์ของตนเองได้ และยังแชร์บางส่วนของฟังก์ชันการทำงานเดียวกันกับ superclass ตัวอย่างเช่น