अमूर्तता और एनकैप्सुलेशन के बीच अंतर?
जवाबों:
यहाँ अधिकांश उत्तर OOP पर केंद्रित हैं, लेकिन इनकैप्सुलेशन बहुत पहले शुरू होता है:
प्रत्येक फ़ंक्शन एक एनकैप्सुलेशन है ; स्यूडोकोड में:
point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y)यहाँ,
distanceएक विमान में दो बिंदुओं के बीच (यूक्लिडियन) दूरी की गणना को समझाया गया है: यह कार्यान्वयन विवरण को छुपाता है। यह एनकैप्सुलेशन, शुद्ध और सरल है।अमूर्तता सामान्यीकरण की प्रक्रिया है : एक ठोस कार्यान्वयन और इसे अलग से लागू करना, कुछ हद तक संबंधित, डेटा के प्रकार। अमूर्तता का शास्त्रीय उदाहरण
qsortडेटा को सॉर्ट करने के लिएC काकार्य है:इसके बारे
qsortमें बात यह है कि यह उस डेटा के बारे में परवाह नहीं करता है जो इसे छाँटता है - वास्तव में, यह नहीं जानता कि यह किस प्रकार का डेटा है। बल्कि, इसका इनपुट प्रकार एक टाइपलेस पॉइंटर (void*) है, जो केवल सी के कहने का तरीका है "मुझे डेटा के प्रकार की परवाह नहीं है" (इसे टाइप इरेज़र भी कहा जाता है)। महत्वपूर्ण बिंदु यह है किqsortडेटा प्रकार की परवाह किए बिना, कार्यान्वयन हमेशा समान रहता है। केवल बात यह है कि है परिवर्तन की तुलना समारोह है, जो अलग डेटा प्रकार से डेटा प्रकार है।qsortइसलिए, उपयोगकर्ता को फ़ंक्शन तर्क के रूप में तुलनात्मक फ़ंक्शन प्रदान करने की अपेक्षा करता है।
इनकैप्सुलेशन और एब्स्ट्रेक्शन हाथ में इतनी जगह जाते हैं कि आप इस बिंदु को बना सकते हैं कि वे वास्तव में अविभाज्य हैं। व्यावहारिक उद्देश्यों के लिए, यह संभवतः सच है; उस ने कहा, यहाँ एक एनकैप्सुलेशन है जो बहुत अमूर्त नहीं है:
class point {
numeric x
numeric y
}
हम बिंदु के समन्वय को संक्षिप्त करते हैं, लेकिन हम उन्हें भौतिक रूप से अलग नहीं करते हैं, उन्हें तार्किक रूप से समूहीकृत करने से परे।
और यहाँ अमूर्त का एक उदाहरण है जो एनकैप्सुलेशन नहीं है:
T pi<T> = 3.1415926535
यह दिए गए मान (,) के साथ एक सामान्य चर है pi , और घोषणा सटीक चर के बारे में परवाह नहीं करती है। वास्तव में, मैं वास्तविक कोड में कुछ इस तरह खोजने के लिए कड़ी मेहनत कर रहा हूँ: अमूर्तता वास्तव में हमेशा एनकैप्सुलेशन का उपयोग करती है। हालांकि, इसके बाद के संस्करण है वास्तव में सी ++ (14) में मौजूद हैं, के माध्यम से चर टेम्पलेट्स (= चर के लिए सामान्य टेम्पलेट्स); थोड़ा और अधिक जटिल वाक्यविन्यास के साथ, जैसे:
template <typename T> constexpr T pi = T{3.1415926535};एन्कैप्सुलेशन कार्यान्वयन विवरण छिपा रहा है जो सामान्य या विशेष व्यवहार (नों) के लिए हो सकता है या नहीं हो सकता है।
अमूर्तता एक सामान्यीकरण प्रदान कर रही है (जैसे, व्यवहार के एक सेट पर)।
यहाँ एक अच्छी रीडिंग है: एब्सट्रैक्शन, इनकैप्सुलेशन, और एडवर्ड वी। बार्ड ऑफ़ द ऑब्जेक्ट एजेंसी द्वारा सूचना छिपाना ।
कई जवाब और उनके उदाहरण भ्रामक हैं।
एनकैप्सुलेशन , उस डेटा पर काम करने वाले डेटा और फ़ंक्शंस की एक एकल घटक में पैकिंग और ऑब्जेक्ट के कुछ घटकों तक पहुंच को प्रतिबंधित करना है।
एनकैप्सुलेशन का अर्थ है कि किसी वस्तु का आंतरिक प्रतिनिधित्व आमतौर पर ऑब्जेक्ट की परिभाषा के बाहर के दृश्य से छिपा होता है।
अमूर्तता एक तंत्र है जो कार्यान्वयन विवरणों को शामिल किए बिना आवश्यक सुविधाओं का प्रतिनिधित्व करता है।
एनकैप्सुलेशन: - सूचना छिपाना ।
अमूर्तता: - कार्यान्वयन छिपाना ।
उदाहरण:
class foo{
private:
int a, b;
public:
foo(int x=0, int y=0): a(x), b(y) {}
int add(){
return a+b;
}
}
fooकक्षा के बाहर किसी भी वस्तु का आंतरिक प्रतिनिधित्व छिपा हुआ है। -> एनकैप्सुलेशन।
किसी वस्तु का कोई सुलभ सदस्य (डेटा / कार्य) fooप्रतिबंधित है और केवल उस वस्तु द्वारा ही पहुँचा जा सकता है।
foo foo_obj(3, 4);
int sum = foo_obj.add();
विधि addका कार्यान्वयन छिपा हुआ है। -> अमूर्तता।
qsortC में फ़ंक्शन का उपयोग अमूर्तता का एक उदाहरण है। आप इसे लागू करने का विवरण नहीं जानते हैं। यहां कोई एनकैप्सुलेशन शामिल नहीं है। C ++ में किसी ऑब्जेक्ट के डेटा फ़ील्ड को इनिशियलाइज़ करने के लिए कंस्ट्रक्टर्स का उपयोग करना एन्कैप्सुलेशन (कंस्ट्रक्टर के माध्यम से ऑब्जेक्ट के घटक तक पहुंच को नियंत्रित करना) का एक उदाहरण है।
एनकैप्सुलेशन कुछ चीजों को एक बॉक्स में रखता है और आपको एक झाँक देता है; यह आपको गियर्स के साथ संभोग करने से रोकता है।
अमूर्त फ्लैट-आउट उन विवरणों को नजरअंदाज कर देता है जो मायने नहीं रखते हैं, जैसे कि क्या चीजों में गियर, रैटचेट्स, फ्लाईव्हील, या परमाणु कोर हैं; वे बस "जाओ"
इनकैप्सुलेशन के उदाहरण:
- जांघिया
- टूलबॉक्स
- बटुआ
- हैंडबैग
- कैप्सूल
- जमे हुए कार्बोनेट
- एक बॉक्स, उसके साथ या उस पर एक बटन के बिना
- एक burrito (तकनीकी रूप से, burrito के आसपास टॉर्टिला)
अमूर्तता के उदाहरण:
- "चीजों का समूह" एक अमूर्त है (जिसे हम एकत्रीकरण कहते हैं)
- "ऐसी चीजें जिनमें अन्य चीजें हैं" एक अमूर्त है (जिसे हम रचना कहते हैं)
- "कंटेनर" एक अन्य प्रकार की "चीजें हैं जिनमें अन्य चीजें शामिल हैं" अमूर्त; ध्यान दें कि सभी एनकैप्सुलेशन उदाहरण कंटेनर के प्रकार हैं, लेकिन सभी कंटेनर एनकैप्सुलेशन को प्रदर्शित / प्रदान नहीं करते हैं। एक टोकरी, उदाहरण के लिए, एक कंटेनर है जो अपनी सामग्री को अलग नहीं करता है।
एनकैप्सुलेशन का मतलब है-डेटा छुपाना, जैसे गेट्टर और सेटर आदि का उपयोग करना।
अमूर्त का मतलब है, छुपा कार्यान्वयन अमूर्त वर्ग और इंटरफेस आदि का उपयोग कर
अमूर्त शब्द सामान्यीकृत है। यानी एनकैप्सुलेशन एब्स्ट्रक्शन का सबसेट है।
उदाहरण 2: समाधान वास्तुकार व्यक्ति जो उच्च स्तरीय बनाता है सार पूरे समाधान के तकनीकी डिजाइन, और इस डिजाइन तो को सौंप दिया है विकास दल के लिए कार्यान्वयन ।
यहाँ, समाधान वास्तुकार एक सार के रूप में कार्य करता है और विकास टीम एक एनकैप्सुलेशन के रूप में कार्य करता है।
उदाहरण 3: उपयोगकर्ता डेटा का एनकैप्सुलेशन (नेटवर्किंग)
अमूर्तन (या प्रतिरूपकता) - प्रकार प्रोग्रामर को बिट या बाइट की तुलना में उच्च स्तर पर सोचने में सक्षम बनाते हैं, निम्न-स्तरीय कार्यान्वयन के साथ परेशान नहीं करते हैं। उदाहरण के लिए, प्रोग्रामर बाइट्स के मात्र सरणी के बजाय चरित्र मानों के एक सेट के रूप में एक स्ट्रिंग के बारे में सोचना शुरू कर सकते हैं। उच्चतर अभी भी, प्रकार प्रोग्रामर को दो-आकार के सब-सिस्टम के बीच इंटरफेस के बारे में सोचने और व्यक्त करने में सक्षम बनाते हैं। यह स्थानीयकरण के अधिक स्तरों को सक्षम बनाता है ताकि उपप्रणालियों की अंतर्संचालनीयता के लिए आवश्यक परिभाषाएं उन दो उपतंत्रों के संचार के समय बनी रहें। स्रोत
ऊपर बहुत सारे अच्छे उत्तर दिए गए हैं, लेकिन मैं अपना (जावा) दृष्टिकोण यहां प्रस्तुत करने जा रहा हूं।
डेटा एनकैप्सुलेशन का सीधा अर्थ है किसी वर्ग में तार्किक रूप से समूहीकृत डेटा की पहुंच को नियंत्रित करना और नियंत्रित करना। यह आम तौर पर किसी अन्य कीवर्ड से जुड़ा होता है - डेटा हाइडिंग । यह एक्सेस मॉडिफायर का उपयोग करके जावा में हासिल किया गया है ।
एक सरल उदाहरण एक निजी चर को परिभाषित करना और गेट्टर और सेटर विधियों का उपयोग करके इसे एक्सेस करना होगा या एक विधि को निजी बनाना होगा क्योंकि यह केवल उपयोग होता है वर्ग को रोक रहा है। इन तरीकों और चर के बारे में जानने के लिए उपयोगकर्ता की कोई आवश्यकता नहीं है।
नोट : यह गलतफहमी नहीं होनी चाहिए कि एनकैप्सुलेशन केवल डेटा छिपाने के बारे में है। जब हम एनकैप्सुलेशन कहते हैं, तो समूहन या पैकेजिंग या संबंधित डेटा और व्यवहार को एक साथ बंडल करने पर जोर दिया जाना चाहिए।
दूसरी ओर डेटा एब्स्ट्रक्शन सामान्यीकरण की अवधारणा है, ताकि उपयोगकर्ता के सामने जटिल तर्क उजागर न हो। जावा में यह इंटरफेस और अमूर्त कक्षाओं का उपयोग करके प्राप्त किया जाता है ।
उदाहरण -
आओ हम कहते हैं कि हमारे पास एक एनिमल है और इसका फंक्शन मेकसाउंड () है । दो ठोस वर्ग डॉग और कैट हैं जो इस इंटरफ़ेस को लागू करते हैं। इन ठोस वर्गों में मेकसाउंड () फ़ंक्शन के अलग-अलग कार्यान्वयन हैं। अब हम कहते हैं कि हमारे पास एक जानवर है (हम इसे किसी बाहरी मॉड्यूल से प्राप्त करते हैं)। सभी उपयोगकर्ता जानते हैं कि यह जो वस्तु प्राप्त कर रहा है वह कुछ एनिमल है और यह उपयोगकर्ताओं की जिम्मेदारी है कि वे जानवरों की ध्वनि को प्रिंट करें। एक जानवर बल तरीका करने के लिए प्राप्त वस्तु की जांच करने के लिए है की पहचान है, यह प्रकार तो समान किरदार कि पशु प्रकार करने के लिए इसे और फिर फोन makeSound () उस पर। लेकिन एक भद्दा रास्ता अमूर्त बात बाहर है । पशु के रूप में उपयोग करेंबहुरूपी संदर्भ और उस पर मेकसाउंड () कॉल करें। पर क्रम क्या वास्तविक ऑब्जेक्ट प्रकार उचित समारोह लागू हो जाएगा पर निर्भर करता है।
अधिक जानकारी यहाँ ।
कॉम्प्लेक्स लॉजिक सर्किट बोर्ड में है जो एक टचपैड में एनकैप्सुलेटेड है और एक अच्छा इंटरफ़ेस (बटन) इसे उपयोगकर्ता को बाहर करने के लिए प्रदान किया गया है।
पुनश्च: उपरोक्त लिंक मेरे व्यक्तिगत ब्लॉग पर हैं।
- अमूर्तता आपको इस बात पर ध्यान केंद्रित करने की अनुमति देती है कि वस्तु क्या करती है इसके बजाय क्या करती है
- एनकैप्सुलेशन का मतलब आंतरिक विवरण या यांत्रिकी को छिपाना है कि कोई वस्तु कुछ कैसे करती है।
जैसे जब आप कार चलाते हैं, तो आप जानते हैं कि गैस पेडल क्या करता है, लेकिन आप इसके पीछे की प्रक्रिया को नहीं जानते होंगे क्योंकि यह एनकैप्सुलेटेड है।
मुझे C # में एक उदाहरण देता हूं। मान लीजिए कि आपके पास पूर्णांक है:
int Number = 5;
string aStrNumber = Number.ToString();
आप Number.ToString () की तरह एक विधि का उपयोग कर सकते हैं जो आपको वर्ण संख्या 5 का प्रतिनिधित्व देता है, और एक स्ट्रिंग ऑब्जेक्ट में संग्रहीत करता है। विधि आपको बताती है कि यह कैसे करता है इसके बजाय यह क्या करता है।
ये कुछ अस्पष्ट अवधारणाएं हैं जो कंप्यूटर विज्ञान और प्रोग्रामिंग के लिए अद्वितीय नहीं हैं। मैं कुछ अतिरिक्त विचारों की पेशकश करना चाहूंगा जो दूसरों को इन महत्वपूर्ण अवधारणाओं को समझने में मदद कर सकते हैं।
संक्षिप्त जवाब
एनकैप्सुलेशन - आवश्यक इंटरफेस को उजागर करते हुए, सिस्टम के कुछ हिस्सों तक पहुंच को छिपाने और / या प्रतिबंधित करना।
अमूर्तता - ठोस वास्तविकताओं, विशिष्ट वस्तुओं या वास्तविक उदाहरणों के अलावा हटाए गए कुछ विशेषताओं को ध्यान में रखते हुए, जिससे जटिलता कम हो जाती है।
मुख्य समानता यह है कि इन तकनीकों का उद्देश्य समझ और उपयोगिता में सुधार करना है।
मुख्य अंतर यह है कि अमूर्त चीजों को अधिक सरलता से दर्शाने का एक साधन है (अक्सर प्रतिनिधित्व को अधिक व्यापक रूप से लागू करने के लिए), जबकि इनकैप्सुलेशन अन्य चीजों को किसी चीज के साथ बातचीत करने के तरीके को बदलने का एक तरीका है।
लंबा जवाब
encapsulation
यहाँ एन्कैप्सुलेशन का एक उदाहरण दिया गया है जो उम्मीद करता है कि चीजें और अधिक स्पष्ट करें:
यहाँ हम एक है Arduino एक बाड़े के भीतर ऊनो, और एक Arduino ऊनो। एक संलग्नक इस बात का एक बड़ा प्रतिनिधित्व है कि इनकैप्सुलेशन क्या है।
इनकैप्सुलेशन का उद्देश्य कुछ घटकों को बाहरी प्रभावों और ज्ञान से बचाने के साथ-साथ उन घटकों को उजागर करना है जिनके साथ अन्य चीजों को इंटरफ़ेस करना चाहिए। प्रोग्रामिंग शब्दों में, यह शामिल है के बारे में जानकारी छुपा हालांकि पहुँच संशोधक , जो किस हद तक कुछ वेरिएबल और / या गुण पढ़ सकते हैं और लिखा जा सकता है बदल जाते हैं।
लेकिन इसके अलावा, इनकैप्सुलेशन का उद्देश्य उन बाहरी इंटरफेस को अधिक प्रभावी रूप से प्रदान करना है। हमारे Arduino उदाहरण के साथ, इसमें अच्छे बटन और स्क्रीन शामिल हो सकते हैं जो डिवाइस के साथ उपयोगकर्ता की बातचीत को बहुत सरल बनाता है। वे उपयोगकर्ता को डिवाइस के व्यवहार को प्रभावित करने और इसके संचालन के बारे में उपयोगी जानकारी प्राप्त करने के सरल तरीके प्रदान करते हैं जो अन्यथा बहुत अधिक कठिन होगा।
प्रोग्रामिंग में, इसमें विभिन्न घटकों को अलग करने योग्य निर्माण में शामिल किया जाता है, जैसे कि function, ए class, या object। इसमें उन निर्माणों के साथ बातचीत करने के साधन, साथ ही उनके बारे में उपयोगी जानकारी प्राप्त करने के तरीके भी शामिल हैं।
इनकैप्सुलेशन प्रोग्रामर्स को कई अतिरिक्त तरीकों से मदद करता है, जिनमें से कम से कम कोड में सुधार और परीक्षण क्षमता में सुधार होता है।
मतिहीनता
यद्यपि यहाँ कई अन्य उत्तरों ने अमूर्तता को सामान्यीकरण के रूप में परिभाषित किया है, मुझे व्यक्तिगत रूप से लगता है कि परिभाषा गुमराह है। मैं कहूंगा कि सामान्यीकरण वास्तव में एक विशिष्ट प्रकार का अमूर्त है, अन्य तरीके से नहीं। दूसरे शब्दों में, सभी सामान्यीकरण सार हैं, लेकिन सभी सार अनिवार्य रूप से सामान्यीकरण नहीं हैं ।
यहाँ मैं कैसे अमूर्त के बारे में सोचना पसंद है:
क्या आप कहेंगे कि एक पेड़ है? संभावना है कि आप करेंगे। लेकिन क्या यह वास्तव में एक पेड़ है? खैर, बिल्कुल नहीं! यह पिक्सल्स का एक गुच्छा है जो कुछ ऐसा दिखता है जिसे हम पेड़ कह सकते हैं। हम कह सकते हैं कि यह एक वास्तविक पेड़ के अमूर्तता का प्रतिनिधित्व करता है। ध्यान दें कि पेड़ के कई दृश्य विवरण छोड़े गए हैं। इसके अलावा, यह बढ़ता नहीं है, पानी का उपभोग करता है, या ऑक्सीजन का उत्पादन करता है। यह कैसे हो सकता है? यह सिर्फ एक स्क्रीन पर रंगों का एक गुच्छा है, जो आपके कंप्यूटर मेमोरी में बाइट्स द्वारा दर्शाया गया है।
और यहाँ अमूर्तता का सार है। यह चीजों को सरल बनाने का एक तरीका है ताकि उन्हें समझना आसान हो। आपके दिमाग से गुजरने वाला हर विचार वास्तविकता का एक अमूर्त हिस्सा है। एक पेड़ की आपकी मानसिक छवि इस जेपीईजी से अधिक वास्तविक पेड़ नहीं है।
प्रोग्रामिंग में, हम इसका उपयोग Treeनकली बढ़ते, पानी की खपत और ऑक्सीजन उत्पादन के तरीकों के साथ एक वर्ग बनाकर अपने लाभ के लिए कर सकते हैं । हमारा निर्माण कुछ ऐसा होगा जो वास्तविक पेड़ों के हमारे अनुभव का प्रतिनिधित्व करता है, और केवल उन तत्वों को शामिल करता है जो हम वास्तव में हमारे विशेष सिमुलेशन के लिए परवाह करते हैं। हम बाइट्स और गणित के साथ किसी चीज़ के अपने अनुभव का प्रतिनिधित्व करने के तरीके के रूप में अमूर्तता का उपयोग करते हैं।
सार वर्ग
प्रोग्रामिंग में अमूर्तता भी हमें कई "ठोस" वस्तु प्रकारों (प्रकार जो वास्तव में मौजूद हैं) के बीच की सामान्यताओं पर विचार करने और उन समानताओं को एक अद्वितीय इकाई के भीतर परिभाषित करने की अनुमति देती है। उदाहरण के लिए, हमारी Treeकक्षा एक से विरासत में मिली हो सकती है abstract class Plant, जिसमें कई गुण और विधियां हैं जो हमारे सभी पौधे जैसी कक्षाओं के लिए लागू हैं, लेकिन उन लोगों को हटा देती हैं जो प्रत्येक प्रकार के पौधे के लिए विशिष्ट हैं। यह कोड के दोहराव को काफी कम कर सकता है, और रखरखाव में सुधार कर सकता है।
एक abstract classऔर सादे classका व्यावहारिक अंतर यह है कि वैचारिक रूप से इसका कोई "वास्तविक" उदाहरण नहीं है abstract class। यह एक Plantवस्तु का निर्माण करने के लिए समझ में नहीं आएगा क्योंकि यह पर्याप्त विशिष्ट नहीं है। प्रत्येक "वास्तविक" Plantभी एक अधिक विशिष्ट प्रकार का है Plant।
इसके अलावा, यदि हम चाहते हैं कि हमारा कार्यक्रम अधिक यथार्थवादी हो, तो हम इस तथ्य पर विचार करना चाहते हैं कि हमारा Treeवर्ग अपने आप में बहुत सारगर्भित हो सकता है। हकीकत में, हर Treeकी एक और अधिक विशिष्ट प्रकार है Tree, तो हम इस तरह के रूप में उन प्रकार के लिए कक्षाएं बना सकते हैं Birch, Mapleआदि हमारे, शायद अब से जो इनहेरिट abstract, Treeवर्ग।
JVM
अमूर्तता का एक और अच्छा उदाहरण जावा वर्चुअल मशीन (जेवीएम) है , जो जावा कोड को चलाने के लिए एक आभासी या सार कंप्यूटर प्रदान करता है। यह अनिवार्य रूप से एक सिस्टम के सभी प्लेटफॉर्म विशिष्ट घटकों को दूर ले जाता है, और विशेष रूप से किसी भी सिस्टम की परवाह किए बिना "कंप्यूटर" का एक सार इंटरफ़ेस प्रदान करता है।
अंतर
इनकैप्सुलेशन, एब्सट्रैक्शन से अलग है कि इसका कुछ 'असली' या 'सटीक' कुछ भी नहीं है। यह सरल या अधिक व्यापक रूप से लागू करने के लिए किसी चीज़ के घटकों को नहीं हटाता है । बल्कि यह एक समान उद्देश्य को प्राप्त करने के लिए कुछ घटकों को छिपा सकता है ।
एनकैप्सुलेशन : वस्तु के वास्तविक उपयोगकर्ताओं से अवांछित / गैर-अपेक्षित / स्वामित्व कार्यान्वयन विवरण छिपा रहा है। जैसे
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**एब्सट्रैक्शन और एनकैप्सुलेशन के बीच अंतर।
अमूर्तता: किसी चीज़ को सरल / अलग तरीके से पेश करने का विचार, जो या तो समझने में आसान हो और स्थिति के लिए अधिक प्रासंगिक हो।
एक वर्ग पर विचार करें जो एक ईमेल भेजता है ... यह स्वयं को किसी प्रकार के दूत लड़के के रूप में दिखाने के लिए अमूर्तता का उपयोग करता है, इसलिए आप emailSender.send (मेल, प्राप्तकर्ता) को कॉल कर सकते हैं। यह वास्तव में क्या करता है - POP3 / SMTP का चयन करता है, कॉलिंग सर्वर, MIME अनुवाद, आदि, दूर सार है। आप केवल अपने दूत लड़के को देखें।
एनकैप्सुलेशन: डेटा और तरीकों को सुरक्षित करने और छिपाने का विचार जो एक वस्तु के लिए निजी हैं। यह कुछ स्वतंत्र और मूर्ख बनाने के साथ अधिक व्यवहार करता है।
उदाहरण के लिए मुझे ले लो। मैं दुनिया के बाकी हिस्सों से अपने दिल की दर को अलग कर देता हूं। क्योंकि मैं नहीं चाहता कि कोई दूसरा उस वैरिएबल को बदले, और मुझे काम करने के लिए किसी और की जरूरत नहीं है। यह मेरे लिए महत्वपूर्ण है, लेकिन आपको यह जानने की आवश्यकता नहीं है कि यह क्या है, और आप शायद वैसे भी परवाह नहीं करते हैं।
अपने आस-पास देखें कि आप पाएंगे कि आपके द्वारा स्पर्श की जाने वाली लगभग हर चीज अमूर्त और अतिक्रमण दोनों का उदाहरण है। मिसाल के तौर पर आपका फोन, आपके सामने यह प्रस्तुत करने में सक्षम है कि आप जो कहते हैं, उसे किसी और से कह सकते हैं - जीएसएम, प्रोसेसर आर्किटेक्चर, रेडियो फ्रिक्वेंसी और एक लाख अन्य चीजों को कवर करना, जिन्हें आप नहीं समझते या देखभाल नहीं करते हैं। यह आपसे कुछ डेटा को भी अलग करता है, जैसे सीरियल नंबर, आईडी नंबर, फ्रीक्वेंसी आदि।
यह सब दुनिया में रहने के लिए एक अच्छा स्थान बनाता है: डी
अमूर्त: केवल आवश्यक जानकारी दिखाई जाती है। आइए कंप्यूटर पर स्विच करने के उदाहरण पर ध्यान दें। उपयोगकर्ता को यह जानने की ज़रूरत नहीं है कि सिस्टम अभी भी लोड हो रहा है (जो जानकारी उपयोगकर्ता से छिपी है) पर क्या हो रहा है।
एक और उदाहरण लेते हैं, वह है एटीएम का। ग्राहक को यह जानने की आवश्यकता नहीं है कि मशीन पिन को कैसे पढ़ती है और लेनदेन को संसाधित करती है, उसे बस इतना करना होगा कि वह पिन में प्रवेश करे, नकदी ले जाए और छोड़ दे।
एनकैप्सुलेशन: एक क्लॉस के संवेदनशील डेटा को छिपाने के साथ सौदा करता है इसलिए इसका हिस्सा निजीकरण करता है। यह अपने ग्राहकों के लिए कुछ जानकारी को निजी रखने का एक तरीका है, जिसमें बाहर से कोई पहुँच नहीं है।
एक और उदाहरण:
मान लीजिए कि मैंने इस तरह एक अपरिवर्तनीय आयत वर्ग बनाया:
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एक सामान्यीकृत उदाहरण का उपयोग करके
-------------------------------------------------- -------------------------------------------------- --------------------------------
हम सभी जटिल समस्याओं की गणना के लिए कैलकुलेटर का उपयोग करते हैं!
Your both example tell about just encapsulation, not abstraction; क्योंकि अमूर्त का इससे कोई लेना-देना hidingनहीं हैGeneralizing
एक तंत्र जो बाहरी कार्यों द्वारा किसी विशेष वस्तुओं के डेटा को जानबूझकर या आकस्मिक दुरुपयोग से सुरक्षित रखता है, उसे " डेटा एन्कोलेशन" कहा जाता है
पृष्ठभूमि विवरण या स्पष्टीकरण सहित बिना आवश्यक सुविधाओं का प्रतिनिधित्व करने का कार्य अमूर्त रूप में जाना जाता है
अमूर्तता: अमूर्तता का मतलब 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
}
}
कंसोल एप्लिकेशन का प्रोग्राम क्लास
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 ++ में कक्षाएं एक्सेस स्पेसिफिकेशंस का उपयोग करती हैं जो यह सुनिश्चित करती हैं कि आकस्मिक पहुंच और संशोधन को रोका जाए। और इसके अलावा, उपर्युक्त इंटरफेस को सार्वजनिक करके, यह सुनिश्चित करता है कि स्टैक में हेरफेर करने का एकमात्र तरीका अच्छी तरह से परिभाषित इंटरफ़ेस के माध्यम से है। इस प्रक्रिया में, इसने डेटा और कोड को जोड़ दिया है जो इसे हेरफेर कर सकता है (चलो दोस्त कार्यों को यहां शामिल न करें)। यही है, कोड और डेटा एक साथ बंधे या बंधे या संकुचित होते हैं।
एनकैप्सुलेशन एक कैप्सूल में जटिलता को लपेट रहा है जो कि वर्ग है और इसलिए एनकैप्सुलेशन ... जबकि अमूर्त एक वस्तु की विशेषताएं हैं जो अन्य ऑब्जेक्ट से अलग करती है ...
एक या एक से अधिक तरीकों को अमूर्त बनाकर एब्स्ट्रेक्शन को क्लास एब्सट्रैक्ट हासिल किया जा सकता है। जो कुछ भी नहीं है, लेकिन जो विशेषता इसे लागू करने वाले वर्ग द्वारा लागू की जानी चाहिए। जैसे जब आप कार का आविष्कार / डिजाइन करते हैं तो आप एक विशेषताओं को परिभाषित करते हैं जैसे कि कार में 4 दरवाजे, ब्रेक, स्टीयरिंग व्हील आदि होना चाहिए ... इसलिए कोई भी इस डिज़ाइन का उपयोग करता है इस विशेषताओं को शामिल करना चाहिए। कार्यान्वयन अमूर्त के प्रत्येक प्रमुख नहीं है। यह सिर्फ उन विशेषताओं को परिभाषित करेगा जिन्हें शामिल किया जाना चाहिए।
एनकैप्सुलेशन डेटा और एक कैप्सूल में व्यवहार को प्राप्त करने के लिए प्राप्त किया जाता है जो वर्ग और सार्वजनिक, निजी, जैसे वंशानुक्रम, एकत्रीकरण या संरचना के साथ संरक्षित संशोधक का उपयोग करके किया जाता है। तो आप केवल आवश्यक चीजों को दिखाते हैं, वह भी केवल उस सीमा तक जिसे आप दिखाना चाहते हैं। अर्थात सार्वजनिक, संरक्षित, मैत्रीपूर्ण और निजी ka funda …… जैसे GM कार के अमूर्त डिज़ाइन का उपयोग करने का निर्णय लेता है। लेकिन उनके पास एक ही विशेषता वाले विभिन्न उत्पाद हैं और लगभग एक ही कार्यक्षमता है। इसलिए वे एक वर्ग लिखते हैं जो उपरोक्त सार वर्ग का विस्तार करता है। यह कहता है कि गियर बॉक्स को कैसे काम करना चाहिए, ब्रेक को कैसे काम करना चाहिए, स्टीयरिंग व्हील को कैसे काम करना चाहिए। फिर सभी उत्पाद केवल इस सामान्य कार्यक्षमता का उपयोग करते हैं। उन्हें नहीं पता है कि गियर बॉक्स कैसे काम करता है या काम करता है या स्टीयरिंग वील काम करता है।
दोनों ही शक्तिशाली हैं; लेकिन एब्सट्रैक्शन का उपयोग करने से एन्कैप्सुलेशन की तुलना में अधिक कौशल की आवश्यकता होती है और एब्सट्रैक्शन से बड़े एप्लिकेशन / उत्पाद बच नहीं सकते हैं।
से इस
OOPS में एनकैप्सुलेशन और एब्स्ट्रक्शन के बीच अंतर
एब्स्ट्रक्शन और एनकैप्सुलेशन दो महत्वपूर्ण ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOPS) अवधारणाएं हैं। एनकैप्सुलेशन और एब्स्ट्रेक्शन दोनों परस्पर संबंधित शब्द हैं।
वास्तविक जीवन अंतर और अंतरविरोध के बीच का अंतर
एनकैप्सुलेट का मतलब छिपाना होता है। एनकैप्सुलेशन को डेटा छिपाना भी कहा जाता है। आप सोच सकते हैं कि एनकैप्सुलेशन एक कैप्सूल (दवा की गोली) की तरह है जो इसके अंदर दवा छुपाता है। एनकैप्सुलेशन रैपिंग है, बस गुणों और तरीकों को छिपा रहा है। दुनिया के बाहर से डेटा की सुरक्षा के लिए कूट और डेटा को एक इकाई में छिपाने के लिए एनकैप्सुलेशन का उपयोग किया जाता है। क्लास इनकैप्सुलेशन का सबसे अच्छा उदाहरण है।
मतिहीनता अभिप्रेत उपयोगकर्ता को केवल आवश्यक विवरण दिखाने के लिए है। जैसा कि नाम से पता चलता है, अमूर्तता "किसी भी चीज़ का अमूर्त रूप" है। हम अमूर्त वर्ग बनाने के लिए प्रोग्रामिंग भाषाओं में अमूर्तता का उपयोग करते हैं। सार वर्ग कक्षा के तरीकों और गुणों के सार दृश्य का प्रतिनिधित्व करता है।
एन्कैप्सुलेशन और एब्सट्रक्शन के बीच कार्यान्वयन अंतर
एब्स्ट्रेक्शन को इंटरफ़ेस और अमूर्त वर्ग का उपयोग करके कार्यान्वित किया जाता है जबकि एनकैप्सुलेशन निजी और संरक्षित एक्सेस संशोधक का उपयोग करके कार्यान्वित किया जाता है।
OOPS प्रोग्रामर को गैर-इच्छित तरीके से डेटा तक पहुँचने से रोककर, एक प्रकार की अखंडता को लागू करने के लिए एन्कैप्सुलेशन का उपयोग करता है (यानी यह सुनिश्चित करने के लिए कि डेटा का उचित तरीके से उपयोग किया जाता है)। एन्कैप्सुलेशन के माध्यम से, केवल कार्यों का एक पूर्व निर्धारित समूह डेटा तक पहुंच सकता है। डेटाटाइप्स और संचालन (विधियों) के लिए सामूहिक शब्द एक साथ प्रतिबंध प्रतिबंध (सार्वजनिक / निजी, आदि) के साथ एक वर्ग है।
मैं एक सरल तरीके से एनकैप्सुलेशन को प्रदर्शित करने की कोशिश करूंगा .. आइए देखें।
- डेटा और फ़ंक्शंस को एक एकल इकाई (जिसे क्लास) कहा जाता है, में रैपिंग को एनकैप्सुलेशन के रूप में जाना जाता है। किसी वस्तु के बारे में जानकारी को छिपाना और छिपाना, जैसे कि आंतरिक डेटा संरचना और कोड।
इनकैप्सुलेशन है -
- जटिलता छिपाना,
- बाइंडिंग डेटा और फ़ंक्शन एक साथ,
- जटिल विधि का निजी बनाना,
- अस्थिरता को निजी बनाते हुए,
- अंतिम उपयोगकर्ता से अनावश्यक डेटा और कार्य को छिपाना।
एनकैप्सुलेशन एब्स्ट्रक्शन को लागू करता है।
और अमूर्तता है -
- Whats आवश्यक दिखा रहा है,
- डेटा को एंड यूज़र से अमूर्त करने की आवश्यकता है,
आइए एक उदाहरण देखें-
नीचे दी गई छवि "ग्राहक विवरण को डेटाबेस में एड-एड करने के लिए" जीयूआई दिखाती है।
छवि को देखकर हम कह सकते हैं कि हमें ग्राहक वर्ग की आवश्यकता है।
चरण - 1: मेरे ग्राहक वर्ग को क्या चाहिए?
अर्थात
- ग्राहक कोड और ग्राहक नाम स्टोर करने के लिए 2 चर।
डेटाबेस में ग्राहक कोड और ग्राहक का नाम जोड़ने के लिए 1 फ़ंक्शन।
namepace CustomerContent {सार्वजनिक वर्ग ग्राहक {public string CustomerCode = ""; सार्वजनिक स्ट्रिंग CustomerName = ""; सार्वजनिक शून्य ADD () {// मेरा DB कोड यहां जाएगा}
अब केवल ADD विधि ही यहाँ काम करेगी।
चरण -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 के बारे में देखना और जानना होगा जो 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 - ऊपर दिया गया कोड कठिन और तेज है।
नीचे के पैराग्राफ ने मुझे यह समझने में मदद की कि वे एक दूसरे से कैसे भिन्न हैं:
डेटा एनकैप्सुलेशन डेटा को बंडल करने का एक तंत्र है, और जो फ़ंक्शन उनका उपयोग करते हैं और डेटा एब्स्ट्रैक्शन केवल इंटरफेस को उजागर करने और उपयोगकर्ता से कार्यान्वयन विवरण को छिपाने का एक तंत्र है।
आप यहां और पढ़ सकते हैं ।
अमूर्तता या एनकैप्सुलेशन के लिए सूचना छिपाना कड़ाई से आवश्यक नहीं है। जानकारी को अनदेखा किया जा सकता है, लेकिन छिपाना नहीं है।
एनकैप्सुलेशन एक चीज़ को एक ही चीज़ के रूप में व्यवहार करने की क्षमता है, भले ही यह कई जटिल भागों या विचारों से बना हो। उदाहरण के लिए, मैं कह सकता हूं कि मैं एक विशिष्ट डिजाइन और कार्य के साथ उस कुर्सी के कई विभिन्न हिस्सों का उल्लेख करने के बजाय एक "कुर्सी" में बैठा हूं, सभी एक साथ आराम से अपने बट को कुछ फीट रखने के उद्देश्य से एक साथ फिटिंग करते हैं मंजिल से दूर।
Abstraction encapsulation द्वारा सक्षम किया गया है। क्योंकि हम वस्तुओं का अतिक्रमण करते हैं, हम उनके बारे में सोच सकते हैं जो आंतरिक वस्तु संरचना के सूक्ष्म विवरणों में फंसने के बजाय किसी तरह से एक दूसरे से संबंधित हैं। अमूर्तता बड़ी तस्वीर पर विचार करने की क्षमता है, कम विवरण पर चिंता से हटा दिया गया है। शब्द की जड़ सार के रूप में सार है जो एक विद्वानों के कागज के शीर्ष पर दिखाई देती है, एक वर्ग के रूप में सार नहीं है जो केवल व्युत्पन्न उपवर्ग के रूप में त्वरित किया जा सकता है।
मैं ईमानदारी से कह सकता हूं कि जब मैं अपने बट को मेरी कुर्सी पर गिराता हूं, तो मैं कभी नहीं सोचता कि उस कुर्सी की संरचना कैसे पकड़ेगी और उसका वजन कैसे पकड़ेगा। यह एक पर्याप्त पर्याप्त कुर्सी है जिसे मुझे उन विवरणों के बारे में चिंता करने की आवश्यकता नहीं है। इसलिए मैं अपना ध्यान अपने कंप्यूटर की ओर मोड़ सकता हूं। और फिर, मैं अपने कंप्यूटर के घटक भागों के बारे में नहीं सोचता। मैं सिर्फ एक वेबपेज का एक हिस्सा देख रहा हूं जो एक टेक्स्ट क्षेत्र का प्रतिनिधित्व करता है जिसे मैं टाइप कर सकता हूं, और मैं शब्दों में संवाद कर रहा हूं, यहां तक कि यह सोचकर कि मेरी उंगलियां हमेशा कीबोर्ड पर सही अक्षर कैसे ढूंढती हैं, और कैसे कनेक्शन अंततः इन कुंजियों के दोहन और इस मंच पर पोस्ट करने के बीच बना है। यह अमूर्तता की महान शक्ति है। क्योंकि सिस्टम के निचले स्तरों को स्थिरता और सटीकता के साथ काम करने के लिए भरोसा किया जा सकता है, इसलिए हमें अधिक से अधिक काम करने के लिए ध्यान देना होगा।
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कार्यान्वयन के लिए एक अनुबंध है जो हम करने जा रहे हैं। समय के साथ कार्यान्वयन में बदलाव हो सकता है। विभिन्न कार्यान्वयन खुद को छिपाया जा सकता है या नहीं किया जा सकता है, लेकिन अमूर्त के पीछे नकाबपोश हैं ।
मान लीजिए कि हम तब के सभी APIsवर्ग को परिभाषित करते हैं, interfaceतो हमारे कोड के उपयोगकर्ताओं को परिभाषित APIsके आधार पर निर्भर होने के लिए कहेंगे interface। हम सुधार को लागू करने या संशोधित करने के लिए स्वतंत्र हैं केवल हमें निर्धारित अनुबंध का पालन करना चाहिए। उपयोगकर्ता हमारे कार्यान्वयन के साथ युग्मित नहीं हैं ।
हम अमूर्तता में सभी नियम नियमों (विधियों) को लागू करते हैं, नियमों का कार्यान्वयन कार्यान्वयनकर्ता संस्थाओं के लिए छोड़ दिया जाता है, कार्यान्वयन भी अमूर्त का हिस्सा नहीं है। यह सिर्फ हस्ताक्षर और घोषणा है जो अमूर्त बनाता है।
Encapsulationबस राज्यों और व्यवहारों की पीड़ा को कम करके आंतरिक विवरण छिपा रहा है। एक समझाया वर्ग अच्छी तरह से परिभाषित हो सकता है या नहीं भी हो सकता है Abstraction।
java.util.Listके लिए एक अमूर्त है java.util.ArrayList। एक्सेस मॉडिफायर्स java.util.ArrayListके साथ चिन्हित होने की आंतरिक स्थिति non publicएनकैप्सुलेशन है।
संपादित
एक वर्ग मान लीजिए Container.nava implements IContainer, IContainerतरीकों की तरह घोषित कर सकता है addElement, removeElements, contains, आदि यहाँ IContainerअपने को लागू करने के लिए वर्ग अमूर्त प्रतिनिधित्व करता है। अमूर्त वर्ग की एपीआई या एक मॉड्यूल या बाहरी दुनिया के लिए एक प्रणाली घोषित कर रहा है। ये API बन जाते हैं contract। वह प्रणाली अभी तक विकसित हो भी सकती है और नहीं भी। सिस्टम के उपयोगकर्ता अब घोषित एपीआई पर निर्भर हो सकते हैं और सुनिश्चित हैं कि इस तरह के अनुबंध को लागू करने वाला कोई भी सिस्टम हमेशा घोषित एपीआई का पालन करेगा, वे हमेशा उन एपीआई के लिए टीजी कार्यान्वयन प्रदान करेंगे। एक बार जब हम कुछ ठोस इकाई लिख रहे होते हैं, तो हमारे आंतरिक राज्यों को छिपाने का निर्णय करना एन्कैप्सुलेशन होता है
आई थिंक एनकैप्सुलेशन एब्सट्रैक्शन को लागू करने का एक तरीका है। निम्नलिखित लिंक पर एक नजर है।
संक्षेप में
अमूर्त उपयोग -> एनकैप्सुलेशन और एनकैप्सुलेशन उपयोग -> डेटा छिपाना
या
डेटा छिपाना एनकैप्सुलेशन का सबसेट है और एनकैप्सुलेशन एब्स्ट्रक्शन का सबसेट है
संदर्भ: http://www.tonymarston.co.uk/php-mysql/abstraction.txt