ในระบบซอฟต์แวร์การห่อหุ้มหมายถึงการรวมข้อมูลเข้ากับกลไกหรือวิธีการที่ดำเนินการกับข้อมูลนั้น นอกจากนี้ยังอาจหมายถึงการจำกัดการเข้าถึงข้อมูลบางส่วนโดยตรง เช่น ส่วนประกอบของวัตถุ^{[ 1 ]}โดยพื้นฐานแล้ว การห่อหุ้มจะป้องกันไม่ให้โค้ดภายนอกเข้าไปเกี่ยวข้องกับการทำงานภายในของวัตถุ

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

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

ระบบ การเขียนโปรแกรมเชิงวัตถุ (OOP) ทั้งหมดรองรับการห่อหุ้ม^{[ 2 ] [ 3 ]}แต่การห่อหุ้มไม่ได้มีเฉพาะใน OOP เท่านั้น การใช้งานประเภทข้อมูลนามธรรมโมดูลและไลบรารี ก็มีการห่อหุ้ม เช่นกัน ความคล้ายคลึงกันนี้ได้รับการอธิบายโดยนักทฤษฎีภาษาการเขียนโปรแกรมในแง่ของประเภทที่มีอยู่^{[ 4 ]}

ในภาษาการเขียนโปรแกรมเชิงวัตถุและสาขาอื่นๆ ที่เกี่ยวข้อง การห่อหุ้มหมายถึงแนวคิดสองอย่างที่เกี่ยวข้องกันแต่แตกต่างกัน และบางครั้งก็หมายถึงการรวมกันของทั้งสองอย่าง: ^{[ 5 ] [ 6 ]}

• กลไกภาษาสำหรับการจำกัดการเข้าถึงโดยตรงไปยังส่วนประกอบบางส่วนของวัตถุ^{[ 7 ] [ 8 ]}
• โครงสร้างภาษาที่อำนวยความสะดวกในการรวมข้อมูลเข้ากับวิธีการ (หรือฟังก์ชันอื่นๆ) ที่ดำเนินการกับข้อมูลเหล่านั้น^{[ 1 ] [ 9 ]}

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

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

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

การห่อหุ้มอาจหมายถึงการบรรจุกระบวนการที่ซ้ำซ้อนหรือซับซ้อนไว้ในหน่วยเดียวเพื่อเรียกใช้ การเขียนโปรแกรมเชิงวัตถุช่วยอำนวยความสะดวกในเรื่องนี้ทั้งในระดับเมธอดและคลาส คำจำกัดความนี้ยังใช้ได้กับการเขียนโปรแกรมเชิงขั้นตอนด้วย^{[ 10 ]}

ผู้เขียนDesign Patternsได้อภิปรายถึงความขัดแย้งระหว่างการสืบทอดและการห่อหุ้มอย่างละเอียด และระบุว่าจากประสบการณ์ของพวกเขา นักออกแบบมักใช้การสืบทอดมากเกินไป พวกเขาอ้างว่าการสืบทอดมักจะทำลายการห่อหุ้ม เนื่องจาก1การสืบทอดทำให้คลาสย่อยเปิดเผยรายละเอียดของการใช้งานของคลาสแม่^{[ 11 ]}ดังที่อธิบายไว้ในปัญหาโยโย่การใช้การสืบทอดมากเกินไปและการห่อหุ้มมากเกินไป อาจทำให้ซับซ้อนและยากต่อการแก้ไขข้อผิดพลาด

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

บางภาษา เช่นSmalltalkและRubyอนุญาตให้เข้าถึงได้เฉพาะผ่านเมธอดของออบเจ็กต์เท่านั้น แต่ภาษาอื่นๆ ส่วนใหญ่ (เช่นC++ , C# , DelphiหรือJava ^{[ 12 ]} ) อนุญาตให้โปรแกรมเมอร์ควบคุมสิ่งที่ซ่อนไว้ได้ โดยทั่วไปผ่านคำหลักเช่น^{และ [}public 8 private] ^{มาตรฐานISO} C++ อ้างถึงและว่าเป็น " ตัวระบุการเข้าถึง " และระบุว่าไม่ได้ "ซ่อนข้อมูลใดๆ" การซ่อนข้อมูลทำได้โดยการจัดเตรียมเวอร์ชันที่คอมไพล์แล้วของซอร์สโค้ดที่เชื่อมต่อผ่านไฟล์ส่วนหัว protectedprivatepublic

โดยส่วนใหญ่แล้ว มักจะมีวิธีการที่จะลบล้างการป้องกันดังกล่าวได้ – โดยปกติแล้วจะใช้API การสะท้อน ( Reflection API) (Ruby, Java, C#, เป็นต้น) บางครั้งอาจใช้กลไกเช่น การแปลงชื่อ (Name Mangling ) ( Python ) หรือการใช้คีย์เวิร์ดพิเศษเช่นfriendใน C++ ระบบที่ให้การรักษาความปลอดภัยตามความสามารถ ระดับวัตถุ (ยึดตามแบบจำลองความสามารถของวัตถุ ) เป็นข้อยกเว้น และรับประกันการห่อหุ้มที่แข็งแกร่ง

ภาษาต่างๆ เช่นC++ , C# , Java , ^{[ 12 ]} PHP , SwiftและDelphiนำเสนอวิธีการจำกัดการเข้าถึงฟิลด์ข้อมูล

ด้านล่างนี้คือตัวอย่างในภาษา C#ที่แสดงให้เห็นถึงวิธีการจำกัดการเข้าถึงฟิลด์ข้อมูลโดยใช้privateคีย์เวิร์ด:

คลาสProgram { คลาสสาธารณะAccount { ตัวแปรส่วนตัวdecimal _accountBalance = 500.00m ;public decimal CheckBalance () { return _accountBalance ; } }static void Main () { Account myAccount = new (); decimal myBalance = myAccount.CheckBalance ( ) ;/* เมธอดหลักนี้สามารถตรวจสอบยอดคงเหลือผ่านเมธอดสาธารณะ "CheckBalance" ที่มีอยู่ในคลาส "Account"  ได้ แต่ไม่สามารถแก้ไขค่าของ "accountBalance" ได้ */ } }

ด้านล่างนี้คือตัวอย่างในภาษา Java :

public class Employee { private BigDecimal salary = new BigDecimal ( 50000.00 ); public BigDecimal getSalary ( ) { return this.salary ; } }public static void main () { Employee e = new Employee (); BigDecimal sal = e . getSalary (); } }

การห่อหุ้มยังสามารถทำได้ในภาษาที่ไม่ใช่เชิงวัตถุ ตัวอย่างเช่น ในภาษา Cโครงสร้างสามารถประกาศได้ใน API สาธารณะผ่านไฟล์ส่วนหัวสำหรับชุดฟังก์ชันที่ดำเนินการกับรายการข้อมูลที่มีสมาชิกข้อมูลที่ไม่สามารถเข้าถึงได้โดยไคลเอนต์ของ API ด้วยexternคำหลัก^{[ 13 ]}

// ไฟล์ส่วนหัว "api.h" #pragma oncetypedef struct Entity Entity ; // โครงสร้างแบบทึบแสงที่มีสมาชิกซ่อนอยู่// ฟังก์ชัน API ที่ทำงานกับอ็อบเจ็กต์ 'Entity' Entity * openEntity ( int id ); int processEntity ( Entity * e ); void closeEntity ( Entity * e );

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

// ไฟล์การใช้งาน "api.c"#รวมไฟล์"api.h"typedef struct Entity { int ent_id ; // หมายเลขประจำตัวchar ent_name [ 20 ]; // ชื่อ... และสมาชิกอื่นๆ... } Entity ;// การใช้งานฟังก์ชัน API Entity * openEntity ( int id ) { // ... }int processEntity ( Entity * e ) { // ... }void closeEntity ( Entity * e ) { // ... }

ด้านล่างนี้เป็นตัวอย่างของPythonซึ่งไม่รองรับข้อจำกัดการเข้าถึงตัวแปร อย่างไรก็ตาม ตามธรรมเนียมแล้ว ตัวแปรที่มีชื่อขึ้นต้นด้วยเครื่องหมายขีดล่างควรถือว่าเป็นตัวแปรส่วนตัว^{[ 14 ]}

คลาสCar : def __init__ ( self ) -> None : self . _maxspeed = 200def drive ( self ) -> None : print ( f " ความเร็วสูงสุดคือ{ self._maxspeed } . " )redcar : Car = Car () redcar . drive () # นี่จะพิมพ์ 'ความเร็วสูงสุดคือ 200'redcar._maxspeed = 10 redcar.drive () # จะแสดงข้อความ 'ความเร็วสูงสุดคือ10 '

• การสืบทอด (การเขียนโปรแกรมเชิงวัตถุ)
• การเขียนโปรแกรมเชิงวัตถุ
• รูปแบบการออกแบบซอฟต์แวร์
• รูปแบบด้านหน้าอาคาร