การสรุปข้อมูล VS การสรุปข้อมูล Encapsulation

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

ฉันสับสน. สิ่งที่เป็นนามธรรมจะซ่อนการใช้รายละเอียดและข้อมูลที่ซ่อนอยู่ในบทคัดย่อรายละเอียดทั้งหมดของบางสิ่งบางอย่าง

อัปเดต:ฉันพบคำตอบที่ดีสำหรับแนวคิดทั้งสามนี้ ดูคำตอบที่แยกต่างหากด้านล่างหลายอ้างอิงที่นำมาจากที่นั่น

ไปที่แหล่งที่มา! Grady Booch พูดว่า (ในการวิเคราะห์เชิงวัตถุและการออกแบบหน้า 49 ฉบับที่สอง):

Abstraction และ encapsulation เป็นแนวคิดเสริม: Abstraction มุ่งเน้นไปที่พฤติกรรมที่สังเกตได้ของวัตถุ ... encapsulation มุ่งเน้นไปที่การปฏิบัติที่ก่อให้เกิดพฤติกรรมนี้ ... การห่อหุ้มนั้นมักจะเกิดจากการซ่อนข้อมูลซึ่งเป็นกระบวนการของการซ่อนทั้งหมด ความลับของวัตถุที่ไม่ได้มีส่วนร่วมในลักษณะสำคัญ

ในคำอื่น ๆ : นามธรรม = วัตถุภายนอก; การห่อหุ้ม (ทำได้โดยการซ่อนข้อมูล) = วัตถุภายใน

ตัวอย่าง: ใน. NET Framework System.Text.StringBuilderคลาสจะให้สิ่งที่เป็นนามธรรมบนบัฟเฟอร์สตริง สิ่งที่เป็นนามธรรมของบัฟเฟอร์นี้ช่วยให้คุณทำงานกับบัฟเฟอร์โดยไม่คำนึงถึงการใช้งาน ดังนั้นคุณสามารถผนวกสตริงเข้ากับบัฟเฟอร์โดยไม่คำนึงถึงวิธีการStringBuilderติดตามภายในของสิ่งต่าง ๆ เช่นตัวชี้ไปยังบัฟเฟอร์และการจัดการหน่วยความจำเมื่อบัฟเฟอร์เต็ม (ซึ่งเกี่ยวข้องกับการห่อหุ้มด้วยการซ่อนข้อมูล)

RP

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

(การอ้างอิงทั้งหมดนำมาจากบทความที่กล่าวถึงข้างต้น)

abstraction:

"จุดหนึ่งของความสับสนเกี่ยวกับสิ่งที่เป็นนามธรรมคือการใช้ทั้งกระบวนการและเอนทิตี้. Abstraction เป็นกระบวนการหมายถึงการแยกรายละเอียดที่สำคัญเกี่ยวกับรายการหรือกลุ่มของรายการโดยไม่สนใจรายละเอียดที่ไม่จำเป็น Abstraction เป็น เอนทิตีหมายถึงโมเดลมุมมองหรือการนำเสนอที่เน้นบางอย่างสำหรับไอเท็มจริง "

การซ่อนข้อมูล:

"อินเทอร์เฟซหรือคำจำกัดความของมันถูกเลือกให้เปิดเผยน้อยที่สุดเกี่ยวกับผลงานภายใน" - [Parnas, 1972b]

"นามธรรมสามารถใช้ [... ] เป็นเทคนิคในการระบุข้อมูลที่ควรซ่อนอยู่"

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

encapsulation:

"มัน [... ] หมายถึงการสร้างแคปซูลในกรณีที่เป็นอุปสรรคความคิดเกี่ยวกับการสะสมของสิ่งต่าง ๆ " - [Wirfs-Brock et al, 1990]

"เป็นกระบวนการการห่อหุ้มหมายถึงการปิดล้อมหนึ่งรายการหรือมากกว่าภายในคอนเทนเนอร์ […] การห่อหุ้มเป็นเอนทิตีหมายถึงแพ็คเกจหรือกล่องที่มี (มีแนบ) รายการหนึ่งรายการหรือมากกว่า"

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

สรุป:

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

Abstraction กำลังซ่อนรายละเอียดการใช้งานโดยให้เลเยอร์เหนือฟังก์ชันการทำงานพื้นฐาน

Information Hidingกำลังซ่อนข้อมูลที่ได้รับผลกระทบจากการใช้งานนั้น การใช้privateและpublicมาภายใต้นี้ ตัวอย่างเช่นการซ่อนตัวแปรของคลาส

Encapsulationเพียงแค่ใส่ข้อมูลและฟังก์ชั่นที่คล้ายกันทั้งหมดลงในกลุ่มเช่นClassในการเขียนโปรแกรม Packetในเครือข่าย

ผ่านการใช้งานของการเรียนที่เราดำเนินการทั้งหมดสามแนวคิด - Abstraction, Information HidingและEncapsulation

โปรดอย่าซับซ้อนแนวคิดง่ายๆ

การห่อหุ้ม : การห่อข้อมูลและวิธีการลงในหน่วยเดียวคือการห่อหุ้ม (เช่นระดับ)

สิ่งที่เป็นนามธรรม : มันเป็นการกระทำที่แสดงถึงสิ่งที่จำเป็นเท่านั้นโดยไม่รวมถึงรายละเอียดเบื้องหลัง (เช่นอินเทอร์เฟซ)

สำหรับตัวอย่างและข้อมูลเพิ่มเติม GOTO:

http://thecodekey.com/C_VB_Codes/Encapsulation.aspx

http://thecodekey.com/C_VB_Codes/Abstraction.aspx

คำจำกัดความที่อนุมัติแล้วที่นี่

PS: ฉันยังจำคำนิยามจากหนังสือชื่อ C ++ โดย Sumita Arora ที่เราอ่านในชั้นที่ 11;)

ความหมายของนามธรรมที่กำหนดโดย Oxford English Dictionary (OED) ใกล้เคียงกับความหมายที่ตั้งใจไว้ที่นี่คือ 'การกระทำของการแยกในความคิด' คำนิยามที่ดีขึ้นอาจเป็น 'การแสดงคุณสมบัติที่จำเป็นของบางสิ่งโดยไม่รวมถึงพื้นหลังหรือรายละเอียดที่ไม่จำเป็น'

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

แก้ไข : ฉันดูเหมือนว่าฉันเป็นนามธรรมที่เป็นกระบวนการของการตัดสินใจที่เป็นส่วนหนึ่งของการดำเนินงานที่ควรจะซ่อน

ดังนั้นข้อมูลที่เป็นนามธรรมจึงไม่ได้ซ่อนอยู่ มันเป็นข้อมูลที่ซ่อนสิ่งที่เป็นนามธรรมผ่าน VIA

สิ่งที่เป็นนามธรรม

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

encapsulation

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

สิ่งที่เป็นนามธรรมจะซ่อนรายละเอียดของการใช้งานตามที่คุณวางไว้

คุณสรุปบางสิ่งบางอย่างให้สูงพอที่คุณจะต้องทำสิ่งที่ง่ายมากในการดำเนินการ

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

แนวคิดทั้งสองนี้เชื่อมโยงกันอย่างใกล้ชิดในการเขียนโปรแกรมเชิงวัตถุ

Abstraction - มันเป็นกระบวนการของการระบุลักษณะสำคัญของวัตถุโดยไม่รวมถึงรายละเอียดที่ไม่เกี่ยวข้องและน่าเบื่อ

Encapsulation - มันเป็นกระบวนการของการล้อมรอบข้อมูลและฟังก์ชั่นการจัดการข้อมูลนี้เป็นหน่วยเดียว

สิ่งที่เป็นนามธรรมและการห่อหุ้มมีความเกี่ยวข้อง แต่แนวคิดเสริม

1. สิ่งที่เป็นนามธรรมเป็นกระบวนการ Encapsulation เป็นกลไกที่ Abstraction ถูกนำไปใช้

2. สิ่งที่เป็นนามธรรมมุ่งเน้นไปที่พฤติกรรมที่สังเกตได้ของวัตถุ Encapsulation มุ่งเน้นไปที่การใช้งานที่ก่อให้เกิดพฤติกรรมนี้

การซ่อนสารสนเทศ - เป็นกระบวนการของการซ่อนรายละเอียดการใช้งานของวัตถุ มันเป็นผลมาจากการห่อหุ้ม

Encapsulation: ผูกพันสมาชิกข้อมูลและฟังก์ชั่นสมาชิกด้วยกันเรียกว่า encapsulation การห่อหุ้มจะทำผ่านชั้นเรียน abstraction: การซ่อนการใช้แบบฟอร์มรายละเอียดการใช้งานหรือจากมุมมองเรียกว่า abstraction เช่น int x; เราไม่ทราบว่า int จะทำงานภายในได้อย่างไร แต่เรารู้ว่า int จะใช้งานได้ นั่นคือสิ่งที่เป็นนามธรรม

Abstraction: Abstraction เป็นแนวคิด / เทคนิคที่ใช้เพื่อระบุสิ่งที่ควรเป็นมุมมองภายนอกของวัตถุ ทำให้เฉพาะอินเทอร์เฟซที่จำเป็นพร้อมใช้งาน

การซ่อนสารสนเทศ:มันเป็นส่วนเสริมของ Abstraction เช่นเดียวกับการปกปิดข้อมูลที่เป็นนามธรรม ซ่อนทุกอย่างอื่นยกเว้นมุมมองภายนอก

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

ดูโพสต์ของโจเอลเกี่ยวกับกฎของ Leaky Abstractions

JoelOnsoftware

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

สำหรับการซ่อนข้อมูลฉันเห็นด้วยกับการติดขัด

ในระยะสั้นมาก

Encapsulation : - การซ่อนข้อมูล

สิ่งที่เป็นนามธรรม : - ซ่อนการดำเนินงาน

Abstractionให้คุณมุ่งเน้นไปที่ในwhat the object doesขณะที่การห่อหุ้มหมายถึงhow an object works

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

การซ่อนข้อมูลนั้นเกี่ยวกับการปกป้อง abstractions ของคุณจากผู้ใช้ที่เป็นอันตราย / ไร้ความสามารถ ด้วยการ จำกัด การควบคุมบางสถานะ (เช่นการจัดสรรฮาร์ดไดรฟ์) ให้กับนักพัฒนาดั้งเดิมการจัดการข้อผิดพลาดจำนวนมากจะกลายเป็นซ้ำซ้อน หากไม่มีใครอื่นนอกจากไดรเวอร์ระบบไฟล์ที่สามารถเขียนไปยังฮาร์ดไดรฟ์ได้แสดงว่าไดรเวอร์ระบบไฟล์นั้นรู้ว่ามีอะไรถูกเขียนไปยังฮาร์ดไดรฟ์และที่ใด (การประกาศตามปกติของแนวคิดนี้คือprivateและprotectedคำหลักในภาษา OO)

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

ดังนั้นการซ่อนข้อมูลเป็นเป้าหมายการนามธรรมเป็นกระบวนการและการห่อหุ้มเป็นเทคนิค

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

เพียงเพิ่มรายละเอียดเพิ่มเติมเกี่ยวกับInformationHidingพบว่าลิงค์นี้เป็นแหล่งข้อมูลที่ดีมากพร้อมตัวอย่าง

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

Encapsulationเป็นคุณสมบัติภาษาการเขียนโปรแกรม

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

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

หลังจากอ่านทั้งหมดข้างต้นคำตอบทีละคนฉันไม่สามารถหยุดตัวเองจากการโพสต์ที่

นามธรรมที่เกี่ยวข้องกับสิ่งอำนวยความสะดวกในการกำหนดวัตถุที่เป็นตัวแทนของ "นักแสดง" นามธรรมที่สามารถทำงานรายงานและเปลี่ยนสถานะของพวกเขาและ "สื่อสาร" กับวัตถุอื่น ๆ ในระบบ

การห่อหุ้มค่อนข้างชัดเจนจากด้านบนอย่างไรก็ตาม ->

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

วิกิอ้างอิง

ฉันก็สับสนอย่างมากเกี่ยวกับแนวคิดสองประการของ Abstraction and Encapsulation แต่เมื่อฉันเห็นบทความ abstractionใน myjavatrainer.com มันชัดเจนสำหรับฉันที่ Abstraction และ Encapsulation เป็นแอปเปิ้ลและส้มคุณไม่สามารถเปรียบเทียบพวกเขาได้จริง ๆ เพราะทั้งสองสิ่งนั้นต้องการ

การห่อหุ้มคือวิธีการสร้างวัตถุและสิ่งที่เป็นนามธรรมคือวิธีการมองวัตถุในโลกภายนอก

Encapsulation:ผูกข้อมูลและวิธีการที่กระทำ สิ่งนี้ทำให้การซ่อนข้อมูลจากวิธีอื่นทั้งหมดในคลาสอื่น ๆ ตัวอย่างเช่นMyListระดับที่สามารถเพิ่มรายการลบรายการและลบรายการทั้งหมดวิธีการadd, removeและremoveAllทำหน้าที่ในรายการ (อาร์เรย์เอกชน) ที่ไม่สามารถเข้าถึงได้โดยตรงจากภายนอก

สิ่งที่เป็นนามธรรม:ซ่อนพฤติกรรมและข้อมูลที่ไม่เกี่ยวข้อง วิธีการจัดเก็บเพิ่มหรือลบรายการจริงถูกซ่อนอยู่ (สรุป) ข้อมูลของฉันอาจถูกจัดเก็บในอาเรย์แบบง่าย ArrayList, LinkedList และอื่น ๆ นอกจากนี้วิธีการใช้งานถูกซ่อนไว้จากภายนอก

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

นามธรรม - การซ่อนรายละเอียดการใช้งานของวิธีการบางอย่างเป็นที่รู้จักกันเป็นนามธรรม

มาทำความเข้าใจด้วยความช่วยเหลือของตัวอย่าง: -

class Rectangle
{
private int length;
private int breadth;// see the word private that means they cant be accesed from 
outside world.
 //now to make them accessed indirectly define getters and setters methods
void setLength(int length)
{  
// we are adding this condition to prevent users to make any irrelevent changes 
  that is why we have made length private so that they should be set according to 
   certain restrictions
if(length!=0)
{
 this.length=length
 }
void getLength()
{
 return length;
 }
 // same do for breadth
}

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

 public int area()
 {
  return length*breadth;
 }

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

มันเป็นมูลค่า noting เงื่อนไขเหล่านี้ได้มาตรฐาน IEEE นิยามซึ่งสามารถสืบค้นที่https://pascal.computer.org/

สิ่งที่เป็นนามธรรม

1. มุมมองของวัตถุที่มุ่งเน้นไปที่ข้อมูลที่เกี่ยวข้องกับวัตถุประสงค์เฉพาะและละเว้นส่วนที่เหลือของข้อมูล
2. กระบวนการกำหนดมุมมอง
3. กระบวนการระงับรายละเอียดที่ไม่เกี่ยวข้องเพื่อสร้างแบบจำลองที่ง่ายขึ้นหรือผลลัพธ์ของกระบวนการนั้น

การซ่อนข้อมูล

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

encapsulation

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