अमूर्त बनाम Encapsulation

Question

संभव डुप्लिकेट:
Abstraction VS Information Hiding VS Encapsulation

मैं जानता हूँ कि इस सवाल का इस मंच पर हजारों बार पूछा गया हो सकता है, यहां तक ​​कि शुद्ध के बारे में भी परिभाषाओं के बहुत से भर जाता है इन अवधारणाओं पर सभी समान लगता है और सभी समान तकनीकी शब्दों का उपयोग करते हैं। उदाहरण के लिए निम्नलिखित परिभाषाएं

Encapsulation डेटा को बाध्यकारी या लपेटने की प्रक्रिया है और डेटा को एक इकाई में डेटा पर संचालित करता है। यह डेटा को बाहरी इंटरफ़ेस से सुरक्षित रखता है और दुरुपयोग करता है। Encapsulation के बारे में सोचने का एक तरीका एक सुरक्षात्मक रैपर के रूप में है जो कोड और डेटा को रैपर के बाहर परिभाषित अन्य कोड द्वारा मनमाने ढंग से एक्सेस करने से रोकता है।

मुझे उपर्युक्त परिभाषा से क्या समझा जाता है यह है कि वेरिएबल्स बनाना, उन्हें निजी चिह्नित करना और उन चर के लिए गेटर-सेटर उत्पन्न करना और उन गेटटर और सेटर तक पहुंचने के लिए ऑब्जेक्ट का उपयोग करना। इस तरह डेटा वस्तु के अंदर छिपा हुआ है और केवल वस्तु के माध्यम से सुलभ है। आशा है कि मैं सही हूँ।

---

अमूर्त जावा में अमूर्त की प्रक्रिया में कुछ विवरण को छिपाने के लिए और केवल वस्तु की आवश्यक सुविधाओं को दिखाने के लिए किया जाता है। दूसरे शब्दों में, यह किसी ऑब्जेक्ट (इंटरफ़ेस) के बाहरी दृश्य से संबंधित है।

अब यह वह हिस्सा है जो मुझे हमेशा भ्रमित करता है। जब भी मैं अमूर्तता के बारे में सोचता हूं जो मेरे दिमाग में आता है वह सार वर्ग है (हो सकता है क्योंकि दोनों में सारशब्द कीवर्ड है)। उपरोक्त परिभाषा का कहना है कि अमूर्तता का अर्थ है डेटा छिपाना और केवल आवश्यक विवरण दिखाना, लेकिन यही वह है जो हम पहले से ही encapsulation में कर रहे हैं? तो क्या अंतर है। इसके अलावा मुझे में ऑब्जेक्ट के बाहरी दृश्य के बारे में पता नहीं चला, यह किसी ऑब्जेक्ट के बाहरी दृश्य से संबंधित है।

क्या कोई इस पर कुछ वास्तविक जीवन उदाहरण या संभवतः कुछ प्रोग्रामेटिक उदाहरणों के साथ अधिक प्रकाश डाल सकता है।

Answer 1

एब्स्ट्रक्शन समानताएं पहचानने और आपके कोड के विभिन्न स्तरों पर काम करने वाली सुविधाओं को कम करने के बारे में है।

उदा। मेरे पास Vehicle कक्षा हो सकती है। CarVehicle से प्राप्त होगा, जैसा कि Motorbike होगा। मैं पहियों, यात्रियों आदि की संख्या के लिए प्रत्येक Vehicle से पूछ सकता हूं और उस जानकारी को Cars और Motorbikes से सामान्य के रूप में समझाया गया है और इसकी पहचान की गई है।

मेरी कोड में मैं अक्सर बस Vehicles साथ सामान्य तरीके go(), stop() आदि मैं बाद में एक नया वाहन का प्रकार जोड़ते हैं (जैसे Scooter) मेरी कोड के बहुमत इस तथ्य से अनजान बने रहेंगे, और के कार्यान्वयन के माध्यम से सौदा कर सकते हैं Scooter अकेले Scooter विशिष्टताओं के बारे में चिंताएं।

Answer 2

OO Abstraction वर्ग स्तर डिजाइन के दौरान होता है, का उद्देश्य, कार्यान्वयन जटिलता की कैसे एक API/डिजाइन/प्रणाली द्वारा की पेशकश की सुविधाओं को लागू किया गया छुपा एक अर्थ में उपयोग करने के लिए 'इंटरफ़ेस' को सरल बनाने के साथ अंतर्निहित कार्यान्वयन।

इस प्रक्रिया को अबास्ट्रक्शन के तेजी से 'उच्च' स्तर (परतों) पर दोहराया जा सकता है, जो उच्च परतों पर कोड और समझ की जटिलता को बढ़ाए बिना बड़े सिस्टम को बनाने में सक्षम बनाता है।

उदाहरण के लिए, जावा डेवलपर FileInputStream की उच्च स्तरीय विशेषताओं का उपयोग कर सकता है, यह चिंता के बिना कि यह कैसे काम करता है (यानी फ़ाइल हैंडल, फ़ाइल सिस्टम सुरक्षा जांच, स्मृति आवंटन और बफरिंग आंतरिक रूप से प्रबंधित की जाएगी, और उपभोक्ताओं से छिपी हुई हैं)। यह FileInputStream को कार्यान्वित करने की अनुमति देता है, और जब तक एपीआई (इंटरफ़ेस) FileInputStream लगातार बना रहता है, पिछले संस्करणों के विरुद्ध बनाए गए कोड अभी भी काम करेंगे।

इसी तरह, जब आप अपनी कक्षाओं को डिजाइन करते हैं, तो आप जितना संभव हो सके दूसरों से आंतरिक कार्यान्वयन छिपाना चाहते हैं।

बूच परिभाषा, और विशेष रूप से चारों ओर , OO EncapsulationInformation Hiding के माध्यम से हासिल की है में आंतरिक डेटा छुपा (क्षेत्रों/सदस्यों राज्य का प्रतिनिधित्व), एक वर्ग उदाहरण के स्वामित्व वाले एक में आंतरिक डेटा तक पहुँच को लागू करके नियंत्रित तरीके से, और इन क्षेत्रों में प्रत्यक्ष, बाहरी परिवर्तन को रोकने, साथ ही कक्षा के किसी भी आंतरिक कार्यान्वयन विधियों को छिपाने के लिए (उदाहरण के लिए उन्हें निजी बनाकर)।

उदाहरण के लिए, एक कक्षाएं 'क्षेत्रों private डिफ़ॉल्ट रूप से बनाया जा सकता है और वह भी तब इन के लिए बाहरी पहुँच आवश्यक था, एक get() और/या set() (या Property) वर्ग से अवगत कराया जाएगा। (आधुनिक ओओ भाषाओं में, फ़ील्ड को readonly/final/immutable के रूप में चिह्नित किया जा सकता है जो कक्षा के भीतर भी परिवर्तन को प्रतिबंधित करता है)।

उदाहरण जहां कोई सूचना नहीं छुपा लागू किया गया है (बुरा प्रैक्टिस):

class Foo { 
    // BAD - NOT Encapsulated - code external to the class can change this field directly 
    // Class Foo has no control over the range of values which could be set. 
    public int notEncapsulated; 
} 

उदाहरण जहां क्षेत्र कैप्सूलीकरण लागू किया गया है:

class Bar { 
    // Improvement - access restricted only to this class 
    private int encapsulated; 

    // The state of Bar (and its fields) can now be changed in a controlled manner 
    public void setEncapsulatedField(int newValue) { 
     if (newValue < 100) { 
      encapsulated = newValue; 
     } 
     // else throw ... out of range 
    } 
} 

अपरिवर्तनीय/constructor- का उदाहरण केवल फ़ील्ड का प्रारंभिकरण:

class Baz { 
    private final int onlyValue; 

    public void Baz(int immutableValue) { 
     // ... can check that immutableValue is valid 
     onlyValue = immutableValue; 
    } 
    // Further change of `onlyValue` outside of the constructor is NOT permitted 
    // even within the same class 
} 

पुन: अमूर्त बनाम सार कक्षा

Abstract classes वर्ग है जो वर्गों के बीच समानता का पुन: उपयोग को बढ़ावा देने के कर रहे हैं, लेकिन जो खुद सीधे new() साथ instantiated नहीं किया जा सकता - सार कक्षाएं subclassed जाना चाहिए, और केवल concrete (गैर सार) subclasses तत्काल हो सकता है। संभावित रूप से Abstraction और abstract class के बीच भ्रम का एक स्रोत यह था कि ओओ के शुरुआती दिनों में, विरासत को कोड पुन: उपयोग करने के लिए अधिक उपयोग किया जाता था (उदा। संबंधित सार आधार वर्गों के साथ)।Encapsulation बनाम सूचना

अभी हाल ही में encapsulation है छिपाना: आजकल, composition is generally favoured over inheritance, और वहाँ इस तरह के इंटरफेस के माध्यम से रूप में और अधिक उपकरण अमूर्त प्राप्त करने के लिए उपलब्ध है,, घटनाओं/प्रतिनिधियों/काम करता है, लक्षण/mixins आदि

पुन हैं आमतौर पर एक वर्ग में bundle पर कौन सी विधियों, फ़ील्ड, गुणों, घटनाओं आदि को निर्धारित करते समय अधिक सामान्य अर्थ में उपयोग किया जाता है।

विकिपीडिया का हवाला देते हुए:

एक वस्तु उन्मुख प्रोग्रामिंग भाषा के अधिक ठोस की स्थापना में, धारणा या तो एक जानकारी छुपा तंत्र, एक बंडलिंग तंत्र, या दोनों के संयोजन मतलब करने के लिए प्रयोग किया जाता है।

उदाहरण के लिए, बयान में "मैं अपने ही वर्ग में डेटा एक्सेस कोड समझाया गया है", कैप्सूलीकरण की व्याख्या मोटे तौर पर Separation of Concerns प्रिंसिपल (ठोस में एस) के बराबर है, और तर्कसंगत रूप से refactoring के पर्याय के रूप में इस्तेमाल किया जा सकता है।

---

^{[1] _{एक बार जब आप बूच के encapsulation cat picture तुम कभी नहीं कैप्सूलीकरण भूल कर सकेंगे देखा है - ऑब्जेक्ट ओरिएंटेड विश्लेषण और अनुप्रयोगों के साथ डिजाइन के P46, 2 एड}}

Answer 3

सरल में शब्द: कार्यान्वित करने का निर्णय लेने पर आप अमूर्तता करते हैं। आपने जो कुछ भी लागू किया है उसे छुपाते समय आप encapsulation करते हैं।