ความแตกต่างที่แม่นยำระหว่างการห่อหุ้มและนามธรรมคืออะไร?

คำตอบส่วนใหญ่ที่นี่ให้ความสำคัญกับ OOP แต่การห่อหุ้มเริ่มเร็วขึ้นมาก:

• ฟังก์ชั่นทุกคนเป็นencapsulation ; ใน pseudocode:

  point x = { 1, 4 }
  point y = { 23, 42 }
  
  numeric d = distance(x, y)
  

  ที่นี่distanceสรุปการคำนวณระยะทาง (ยูคลิด) ระหว่างสองจุดในระนาบ: มันซ่อนรายละเอียดการใช้งาน นี่คือการห่อหุ้มที่บริสุทธิ์และเรียบง่าย

• Abstractionเป็นกระบวนการของการทำให้เป็นลักษณะทั่วไป : การดำเนินการที่เป็นรูปธรรมและทำให้สามารถนำไปใช้กับที่แตกต่างกันแม้ว่าประเภทของข้อมูลที่ค่อนข้างเกี่ยวข้อง ตัวอย่างคลาสสิกของนามธรรมคือ C'sqsortฟังก์ชั่นเพื่อเรียงลำดับข้อมูล:

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

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

class point {
    numeric x
    numeric y
}

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

และนี่คือตัวอย่างของนามธรรมที่ไม่ได้ห่อหุ้ม:

T pi<T> = 3.1415926535

นี่เป็นตัวแปรทั่วไปที่ piมีค่าที่กำหนด (π) และการประกาศไม่สนใจประเภทของตัวแปรที่แน่นอน เป็นที่ยอมรับฉันจะกดยากที่จะหาสิ่งเช่นนี้ในรหัสจริง: นามธรรมมักจะใช้การห่อหุ้ม แต่ข้างต้นไม่อยู่จริงใน C ++ (14) ผ่านทางแม่แบบตัวแปร (= แม่แบบทั่วไปสำหรับตัวแปร); ด้วยไวยากรณ์ที่ซับซ้อนกว่าเล็กน้อยเช่น:

template <typename T> constexpr T pi = T{3.1415926535};

Encapsulationซ่อนรายละเอียดการปฏิบัติซึ่งอาจมีหรือไม่มีพฤติกรรมทั่วไปหรือโดยเฉพาะ

สิ่งที่เป็นนามธรรมให้การวางนัย (พูดผ่านชุดของพฤติกรรม)

นี่คือการอ่านที่ดี: Abstraction, Encapsulation และ Information Hidingโดย Edward V. Berard ของ Object Agency

คำตอบมากมายและตัวอย่างของพวกเขาทำให้เข้าใจผิด

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

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

Encapsulation: - ที่หลบซ่อนข้อมูล
สิ่งที่เป็นนามธรรม: -ซ่อนการดำเนินงานการดำเนินงานที่หลบซ่อนตัว

ตัวอย่าง:

class foo{
    private:
        int a, b;
    public:
        foo(int x=0, int y=0): a(x), b(y) {}

        int add(){    
            return a+b;   
        } 
}  

การเป็นตัวแทนภายในของวัตถุใด ๆ ในfooชั้นเรียนจะถูกซ่อนอยู่นอกชั้นเรียน -> Encapsulation
สมาชิกที่เข้าถึงได้ (ข้อมูล / ฟังก์ชั่น) ของวัตถุfooนั้นถูก จำกัด และสามารถเข้าถึงได้โดยวัตถุนั้นเท่านั้น

foo foo_obj(3, 4);
int sum = foo_obj.add();

การใช้วิธีการaddถูกซ่อนไว้ -> สิ่งที่เป็นนามธรรม

การห่อหุ้มทำให้บางสิ่งในกล่องและให้คุณตาแมว; สิ่งนี้จะช่วยป้องกันไม่ให้คุณล้อเล่นกับเฟือง

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

ตัวอย่างของการห่อหุ้ม:

• กางเกงใน
• กล่องเครื่องมือ
• กระเป๋าสตางค์
• กระเป๋าถือ
• แคปซูล
• คาร์บอเนตแช่แข็ง
• กล่องที่มีหรือไม่มีปุ่มอยู่
• Burrito (ในทางเทคนิค Tortilla รอบ ๆ Burrito)

ตัวอย่างของสิ่งที่เป็นนามธรรม:

• "กลุ่มสิ่งต่าง ๆ " เป็นสิ่งที่เป็นนามธรรม (ซึ่งเราเรียกว่าการรวมตัว)
• "สิ่งที่มีสิ่งอื่น ๆ " เป็นสิ่งที่เป็นนามธรรม (ซึ่งเราเรียกว่าการแต่งเพลง)
• "container" เป็นอีกประเภทหนึ่งของ "สิ่งที่มีสิ่งอื่น" นามธรรม โปรดทราบว่าตัวอย่างของการห่อหุ้มทั้งหมดเป็นชนิดของภาชนะบรรจุ แต่ไม่ใช่ทุกคอนเทนเนอร์ที่แสดง / ให้การห่อหุ้ม ยกตัวอย่างเช่นตะกร้าเป็นภาชนะบรรจุที่ไม่ได้ห่อหุ้มเนื้อหาของมัน

การห่อหุ้มข้อมูลหมายถึงการซ่อนข้อมูลเช่นการใช้ตัวรับและตัวตั้งค่าเป็นต้น

ความหมายที่เป็นนามธรรม - การซ่อนการใช้งานโดยใช้คลาสนามธรรมและอินเตอร์เฟส ฯลฯ

นามธรรมเป็นศัพท์ทั่วไป เช่น Encapsulation เป็นส่วนย่อยของ Abstraction

• ตัวอย่างที่ 2: สถาปนิกวิธีการแก้ปัญหาคือคนที่สร้างระดับสูงนามธรรมการออกแบบทางเทคนิคของการแก้ปัญหาทั้งหมดและการออกแบบนี้ถูกส่งจากนั้นไปที่ทีมพัฒนาสำหรับการดำเนินงาน
  การดำเนินงาน

  สถาปนิกแก้ปัญหาทำหน้าที่เป็นนามธรรมและทีมพัฒนาทำหน้าที่เป็น Encapsulation

• ตัวอย่างที่ 3: การห่อหุ้ม (เครือข่าย) ของข้อมูลผู้ใช้

มารยาท

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

มีคำตอบที่ดีมากมายไว้ด้านบน แต่ฉันจะนำเสนอมุมมอง (Java) ของฉันที่นี่

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

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

บันทึก : ไม่ควรเข้าใจผิดว่าการห่อหุ้มนั้นเกี่ยวข้องกับการซ่อนข้อมูลเท่านั้น เมื่อเราพูดว่าการห่อหุ้มควรเน้นการจัดกลุ่มหรือบรรจุภัณฑ์หรือรวมข้อมูลและพฤติกรรมที่เกี่ยวข้องเข้าด้วยกัน

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

ตัวอย่าง -

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

รายละเอียดเพิ่มเติมที่นี่

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

PS: ลิงค์ด้านบนมีไว้ในบล็อกส่วนตัวของฉัน

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

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

ขอยกตัวอย่างเป็น C # สมมติว่าคุณมีจำนวนเต็ม:

int Number = 5;
string aStrNumber = Number.ToString();

คุณสามารถใช้วิธีการเช่น Number.ToString () ซึ่งจะคืนค่าตัวอักษรที่เป็นตัวแทนของหมายเลข 5 และเก็บไว้ในวัตถุสตริง วิธีนี้บอกให้คุณรู้ว่ามันทำอะไรแทนวิธีทำ

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

คำตอบสั้น ๆ

encapsulation - ซ่อนและ / หรือ จำกัด การเข้าถึงบางส่วนของระบบในขณะที่เปิดเผยส่วนต่อประสานที่จำเป็น

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

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

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

คำตอบยาว ๆ

encapsulation

นี่คือตัวอย่างของการห่อหุ้มที่หวังว่าจะทำให้สิ่งต่าง ๆ ชัดเจนยิ่งขึ้น:

ที่นี่เรามีArduino Uno และ Arduino Uno ภายในกล่องหุ้ม สิ่งที่แนบมาเป็นตัวแทนที่ดีของสิ่งที่เป็นเรื่องเกี่ยวกับการห่อหุ้ม

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

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

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

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

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

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

นี่คือวิธีที่ฉันคิดว่าเป็นนามธรรม:

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

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

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

คลาสนามธรรม

นามธรรมในการเขียนโปรแกรมยังช่วยให้เราสามารถพิจารณา commonalities ระหว่างประเภทวัตถุ "คอนกรีต" (ประเภทที่มีอยู่จริง) และกำหนด commonalities เหล่านั้นภายในนิติบุคคลที่ไม่ซ้ำกัน ตัวอย่างเช่นTreeคลาสของเราอาจสืบทอดจากabstract class Plantซึ่งมีคุณสมบัติและวิธีการหลายอย่างที่ใช้กับคลาสที่เหมือนพืชของเราทั้งหมด แต่จะลบคลาสที่มีลักษณะเฉพาะกับพืชแต่ละชนิด สิ่งนี้สามารถลดความซ้ำซ้อนของรหัสและปรับปรุงการบำรุงรักษา

ความแตกต่างในทางปฏิบัติของabstract classและธรรมดาclassก็คือแนวคิดที่ไม่มี "ของจริง" abstract classกรณีของ มันคงไม่มีเหตุผลที่จะสร้างPlantวัตถุเพราะมันไม่เจาะจงพอ ทุกคน "ของจริง" ยังเป็นประเภทที่เฉพาะเจาะจงมากขึ้นของPlantPlant

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

JVM

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

ความแตกต่าง

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

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

List<string> list = new List<string>();
list.Sort(); /* Here, which sorting algorithm is used and hows its 
implemented is not useful to the user who wants to perform sort, that's 
why its hidden from the user of list. */

สิ่งที่เป็นนามธรรม : เป็นวิธีการให้ความเห็นทั่วไปและด้วยวิธีการทั่วไปในการทำงานกับวัตถุที่มีความหลากหลายมากมาย เช่น

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

ความแตกต่างระหว่าง Abstraction และ Encapsulation

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

พิจารณาคลาสที่ส่งอีเมล ... ใช้นามธรรมเพื่อแสดงตัวคุณเป็นผู้ส่งสารบางชนิดดังนั้นคุณสามารถโทรหา emailSender.send (เมลผู้รับ) ใช้งานได้จริง - เลือก POP3 / SMTP, เซิร์ฟเวอร์โทร, การแปล MIME, และอื่น ๆ , ถูกแยกออกไป คุณเห็นเด็กชายร่อซู้ลของคุณเท่านั้น

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

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

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

มันทำให้โลกเป็นสถานที่ที่ดีกว่าสำหรับการอยู่อาศัย: D

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

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

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

ตัวอย่างอื่น:

สมมติว่าฉันสร้างคลาสสี่เหลี่ยมผืนผ้าที่ไม่เปลี่ยนรูปแบบเช่นนี้:

class Rectangle {
 public:
  Rectangle(int width, int height) : width_(width), height_(height) {}
  int width() const { return width_; }
  int height() const { return height_; }

 private:
  int width_;
  int height_;
}

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

นามธรรมที่ดีมักจะหมายถึงการห่อหุ้มที่ดี

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

AbstractionและEncapsulationโดยใช้ตัวอย่างทั่วไปเดียว

-------------------------------------------------- -------------------------------------------------- --------------------------------

เราทุกคนใช้เครื่องคิดเลขสำหรับการคำนวณปัญหาที่ซับซ้อน!

กลไกที่ป้องกันไม่ให้ข้อมูลของวัตถุใด ๆ ปลอดภัยจากการใช้งานโดยเจตนาหรือไม่ตั้งใจโดยเรียกว่า " data Encapsulation"

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

สิ่งที่เป็นนามธรรม: สิ่งที่เป็นนามธรรมหมายถึงการแสดงWhatส่วนหนึ่งของการทำงาน

การห่อหุ้ม: การห่อหุ้มหมายถึงการซ่อนHowส่วนหนึ่งของการทำงาน

ลองยกตัวอย่างง่ายๆ

/// <summary>
/// We have an Employee class having two properties EmployeeName and EmployeeCode
/// </summary>
public class Employee
{
    public string EmplpyeeName { get; set; }
    public string EmployeeCode { get; set; }

    // Add new employee to DB is the main functionality, so are making it public so that we can expose it to external environment
    // This is ABSTRACTION
    public void AddEmployee(Employee obj)
    {
        // "Creation of DB connection" and "To check if employee exists" are internal details which we have hide from external environment
        // You can see that these methods are private, external environment just need "What" part only
        CreateDBConnection();
        CheckIfEmployeeExists();
    }


    // ENCAPLUSATION using private keyword
    private bool CheckIfEmployeeExists()
    {
        // Here we can validate if the employee already exists
        return true;
    }

    // ENCAPLUSATION using private keyword
    private void CreateDBConnection()
    {
        // Create DB connection code
    }
}

คลาสโปรแกรมของ Console Application

class Program
{
    static void Main(string[] args)
    {
        Employee obj = new Employee();
        obj.EmplpyeeName = "001";
        obj.EmployeeCode = "Raj";

        // We have exposed only what part of the functionality
        obj.AddEmployee(obj);
    }
}

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

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

Encapsulation เป็นการรวมความซับซ้อนไว้ในแคปซูลเดียวนั่นคือคลาส & ด้วยเหตุนี้ Encapsulation ... ในขณะที่นามธรรมเป็นลักษณะของวัตถุที่แตกต่างจากวัตถุอื่น ...

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

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

ทั้งสองมีพลัง แต่การใช้สิ่งที่เป็นนามธรรมนั้นต้องใช้ทักษะมากกว่า encapsulation และแอพพลิเคชั่น / ผลิตภัณฑ์ที่ใหญ่กว่านั้นไม่สามารถอยู่รอดได้โดยไม่ต้องใช้สิ่ง

สิ่งที่เป็นนามธรรม --- การซ่อนการใช้งาน - ที่การออกแบบ --- การใช้ calsses ของอินเทอร์เฟซ / บทคัดย่อ

Encapsulation - การซ่อนข้อมูล - การพัฒนา --- การใช้ตัวดัดแปลงการเข้าถึง (สาธารณะ / ส่วนตัว)

จากนี้

ความแตกต่างระหว่าง Encapsulation และ Abstraction ใน OOPS

Abstraction and Encapsulation เป็นแนวคิดที่สำคัญสองประการเกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ (OOPS) Encapsulation และ Abstraction ทั้งสองเป็นคำที่เกี่ยวข้องกัน

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

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

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

ความแตกต่างระหว่างการใช้งานการห่อหุ้มและนามธรรม

1. สิ่งที่เป็นนามธรรมจะดำเนินการโดยใช้อินเตอร์เฟซและระดับนามธรรมในขณะที่ Encapsulation จะดำเนินการโดยใช้ส่วนตัวและป้องกันการเข้าถึงที่ได้รับการป้องกัน

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

ฉันจะพยายามแสดงให้เห็นถึงการห่อหุ้มด้วยวิธีง่าย ๆ .. ให้ดู ..

• การรวมข้อมูลและฟังก์ชั่นไว้ในหน่วยเดียว (เรียกว่าคลาส) เรียกว่า encapsulation การห่อหุ้มที่มีและซ่อนข้อมูลเกี่ยวกับวัตถุเช่นโครงสร้างข้อมูลภายในและรหัส

การห่อหุ้มคือ -

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

Encapsulation ใช้ Abstraction

และสิ่งที่เป็นนามธรรม -

• แสดงสิ่งที่จำเป็น
• ความต้องการข้อมูลที่เป็นนามธรรมจากผู้ใช้

ให้ดูตัวอย่าง -

รูปภาพด้านล่างแสดง GUI ของ "รายละเอียดลูกค้าที่จะเพิ่มเข้าไปในฐานข้อมูล"

โดยการดูที่รูปภาพเราสามารถพูดได้ว่าเราต้องการระดับลูกค้า

ขั้นตอนที่ 1: ระดับลูกค้าของฉันต้องการอะไร?

กล่าวคือ

• 2 ตัวแปรในการจัดเก็บรหัสลูกค้าและชื่อลูกค้า

• 1 ฟังก์ชั่นเพื่อเพิ่มรหัสลูกค้าและชื่อลูกค้าลงในฐานข้อมูล

  เนมสเปซ CustomerContent {ลูกค้าระดับสาธารณะ {สตริงสาธารณะ CustomerCode = ""; สตริงสาธารณะ CustomerName = ""; โมฆะสาธารณะเพิ่ม () {// รหัส DB ของฉันจะไปที่นี่}

ตอนนี้วิธีการเพิ่มเท่านั้นจะไม่ทำงานที่นี่เพียงอย่างเดียว

ขั้นตอนที่ 2: การตรวจสอบจะทำงานอย่างไรฟังก์ชั่น ADD จะทำหน้าที่อย่างไร

เราจะต้องใช้รหัสการเชื่อมต่อฐานข้อมูลและรหัสการตรวจสอบ (วิธีการพิเศษ)

public bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

public bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";
obj.CustomerName = "Mac";

obj.Validate();
obj.CreateDBObject();

obj.ADD();
}
}

ขณะนี้ไม่จำเป็นต้องแสดงวิธีการพิเศษ (ตรวจสอบ (); CreateDBObject () [วิธีการที่ซับซ้อนและพิเศษ]) ต่อผู้ใช้ปลายทางผู้ใช้และผู้ใช้จะต้องเห็นและทราบเกี่ยวกับรหัสลูกค้าชื่อลูกค้าและปุ่ม ADD ซึ่งจะเพิ่ม บันทึก .. ผู้ใช้ปลายทางไม่สนใจว่าจะเพิ่มข้อมูลลงในฐานข้อมูลได้อย่างไร

ขั้นตอนที่ -3: ส่วนตัววิธีพิเศษและซับซ้อนที่ไม่เกี่ยวข้องกับการโต้ตอบของผู้ใช้

ดังนั้นการทำให้ซับซ้อนและวิธีการพิเศษเหล่านั้นเป็นส่วนตัวแทนสาธารณะ (เช่นการซ่อนวิธีการเหล่านั้น) และการลบ obj.Validate (); obj.CreateDBObject (); จากโปรแกรมหลักในชั้นเรียนเราได้รับการห่อหุ้ม

กล่าวอีกนัยหนึ่งว่าอินเทอร์เฟซสำหรับผู้ใช้ปลายทางคือการห่อหุ้ม

ดังนั้นตอนนี้รหัสดูเหมือนเป็นด้านล่าง -

namespace CustomerContent
{
public class Customer
{
public string CustomerCode = "";
public string CustomerName = "";
public void ADD()
{
   //my DB code will go here
}

private bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

private bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";

obj.CustomerName = "Mac";

obj.ADD();
}
}

สรุป :

ขั้นตอนที่ 1: ระดับลูกค้าของฉันต้องการอะไร เป็นนามธรรม

ขั้นตอนที่ 3: ขั้นตอนที่ 3: วิธีการพิเศษและซับซ้อนที่ไม่เกี่ยวข้องกับการโต้ตอบของผู้ใช้คือการห่อหุ้มข้อมูล

PS - รหัสด้านบนนั้นยากและรวดเร็ว

ย่อหน้าด้านล่างช่วยให้ฉันเข้าใจว่าพวกเขาแตกต่างกันอย่างไร:

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

คุณสามารถอ่านเพิ่มเติมที่นี่

ไม่จำเป็นต้องปิดบังข้อมูลเพื่อให้เป็นนามธรรมหรือ encapsulation ข้อมูลอาจถูกละเว้น แต่ไม่จำเป็นต้องซ่อน

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

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

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

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

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

กระบวนการของ Abstraction และ Encapsulation ทั้งคู่สร้างอินเตอร์เฟส

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

อินเทอร์เฟซที่สร้างขึ้นผ่านนามธรรมจะสามารถใช้งานกับชนิดข้อมูลได้มากขึ้นเมื่อเทียบกับก่อนหน้านามธรรม

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

สมมติว่าเรากำหนดทั้งหมดAPIsของชั้นในinterfaceแล้วขอให้ผู้ใช้รหัสของเราที่จะ depened อยู่กับการกำหนดของAPIs interfaceเรามีอิสระที่จะปรับปรุงหรือแก้ไขการนำไปใช้เท่านั้นที่เราจะต้องปฏิบัติตามสัญญาที่กำหนดไว้ ผู้ใช้ไม่ได้เชื่อมโยงกับการใช้งานของเรา

เราเปิดเผยกฎทั้งหมดที่จำเป็น (วิธีการ) ในนามธรรมการดำเนินการของกฎที่เหลือสำหรับหน่วยงานผู้ดำเนินการนอกจากนี้การดำเนินการไม่ได้เป็นส่วนหนึ่งของสิ่งที่เป็นนามธรรม มันเป็นเพียงลายเซ็นและการประกาศสิ่งที่ทำให้สิ่งที่เป็นนามธรรม

Encapsulationเป็นเพียงการซ่อนรายละเอียดภายในโดยการลด acess ของรัฐและพฤติกรรม Abstractionชั้นห่อหุ้มหรืออาจจะไม่ได้กำหนดไว้อย่างดี

java.util.Listjava.util.ArrayListเป็นนามธรรมสำหรับ สถานะภายในของjava.util.ArrayListการถูกทำเครื่องหมายด้วยnon publicตัวดัดแปลงการเข้าถึงคือการห่อหุ้ม

แก้ไข สมมติว่าชั้นเรียนContainer.nava implements IContainer, IContainerอาจประกาศวิธีการเช่นaddElement, removeElements, containsฯลฯ นี่IContainerแสดงให้เห็นถึงสิ่งที่เป็นนามธรรมสำหรับการเรียนในการดำเนินการของ สิ่งที่เป็นนามธรรมคือการประกาศ API ของคลาสหรือโมดูลหรือระบบไปยังโลกภายนอก API contractเหล่านี้กลายเป็น ระบบนั้นอาจจะมีหรือไม่มีการพัฒนาเลยก็ได้ ขณะนี้ผู้ใช้ระบบสามารถขึ้นอยู่กับ API ที่ประกาศไว้และมั่นใจว่าระบบใด ๆ ที่ใช้สัญญาดังกล่าวจะต้องปฏิบัติตาม API ที่ประกาศไว้เสมอ เมื่อเราเขียนเอนทิตี้ที่เป็นรูปธรรมบางอย่างแล้วการตัดสินใจซ่อนสถานะภายในของเราคือการห่อหุ้ม

ฉันคิดว่า Encapsulation เป็นวิธีการใช้นามธรรม ดูที่ลิงค์ต่อไปนี้

สิ่งที่เป็นนามธรรมและการห่อหุ้ม

ในระยะสั้น

การใช้นามธรรม -> การห่อหุ้ม และการ ใช้การห่อหุ้ม -> การซ่อนข้อมูล

หรือ

การซ่อนข้อมูลเป็นส่วนหนึ่งของ Encapsulationและ Encapsulation เป็นส่วนย่อยของ Abstraction

การอ้างอิง: http://www.tonymarston.co.uk/php-mysql/abstraction.txt