oop Encapsulation और Abstraction को समझने का सरल तरीका




language-agnostic (10)

ओओपी अवधारणाओं को सीखना विशेष रूप से गहराई में एब्स्ट्रक्शन और Encapsulation को समझने में रुचि रखते हैं।

पहले से ही नीचे की जाँच की

एब्स्ट्रक्शन वीएस सूचना छुपा वीएस Encapsulation

अमूर्तता और encapsulation के बीच अंतर?

मुझे वास्तविक और सरल उदाहरण वर्ग / कोड स्निपेट के साथ उन अवधारणाओं को समझना बहुत मुश्किल लगता है।

मेरे सहयोगियों में से एक ने कहा कि अमूर्त कुछ भी नहीं है बल्कि अमूर्त वर्ग और सामान्य वर्ग बना रहा है जो अपने सदस्य चर को दायरे से बचाता है जिसे Encapsulation कहा जाता है।

क्या कोई आसान तरीका है जिसे मैं समझ सकता हूं और दूसरों को यह समझने में सहायता करता हूं कि वे वास्तव में क्या हैं, नीचे दिए गए दोहराने के बजाय?

अमूर्त और encapsulation पूरक अवधारणाओं हैं: abstraction एक वस्तु के देखने योग्य व्यवहार पर केंद्रित है ... encapsulation कार्यान्वयन पर केंद्रित है जो इस व्यवहार को जन्म देता है ... encapsulation अक्सर जानकारी छुपा के माध्यम से हासिल किया जाता है, जो सभी को छिपाने की प्रक्रिया है ऑब्जेक्ट के रहस्य जो इसकी आवश्यक विशेषताओं में योगदान नहीं देते हैं।


डेटा एब्स्ट्रक्शन : डीए बस कंक्रीट आइटम को फ़िल्टर कर रहा है। कक्षा के अनुसार हम शुद्ध अमूर्तता प्राप्त कर सकते हैं, क्योंकि कक्षा बनाने से पहले हम केवल वर्ग के बारे में संबंधित जानकारी के बारे में सोच सकते हैं।

Encapsulation : यह एक तंत्र है, जिसके द्वारा हम अपने डेटा को बाहर से सुरक्षित करते हैं।


डेटा अबास्ट्रक्शन: किसी भी वर्ग के डेटा सदस्यों और सदस्य कार्यों तक पहुंच को केवल डेटा एब्स्ट्रक्शन कहा जाता है .....

encapsulation: बाध्यकारी चर और कार्यों या 1 डेटा समूह या सदस्य कार्यों को एक ही इकाई में एक साथ कह सकते हैं डेटा डेटा encapsulation के रूप में कहा जाता है ....


एब्स्ट्रक्शन एक कंप्यूटर का उपयोग करने की तरह है।

आप जीयूआई (ग्राफिकल यूजर इंटरफेस) और बाहरी हार्डवेयर (जैसे स्क्रीन) के साथ जो देखते हैं उससे परे क्या हो रहा है, इसके बारे में आपको बिल्कुल पता नहीं है। उन सभी सुंदर रंगों और ऐसे। आपको केवल एक सामान्य उपभोक्ता के रूप में प्रासंगिक विवरण प्रस्तुत किए गए हैं।

अपरिवर्तनीय अप्रासंगिक विवरण छिपाने का वास्तविक कार्य है।

आप अपने कंप्यूटर का उपयोग करते हैं, लेकिन आप नहीं देखते हैं कि इसका सीपीयू (केंद्रीय प्रसंस्करण इकाई) कैसा दिखता है (जब तक कि आप इसे तोड़ने की कोशिश न करें)। यह क्रोम और प्लास्टिक के पीछे छुपा हुआ है (या encapsulated)।

ओओपी (ऑब्जेक्ट उन्मुख प्रोग्रामिंग) भाषाओं के संदर्भ में, आपके पास आमतौर पर इस प्रकार का सेटअप होता है:

CLASS {
  METHOD { 
    *the actual code*
  }
}

"Encapsulation" का एक उदाहरण एक METHOD होगा कि नियमित उपयोगकर्ता (निजी) नहीं देख सकता है। "एब्स्ट्रक्शन" नियमित उपयोगकर्ता का उपयोग करने के लिए METHOD का उपयोग कर नियमित उपयोगकर्ता है (वे) कर सकते हैं।


एब्स्ट्रक्शन एक ऐसी प्रक्रिया है जहां आप केवल "प्रासंगिक" डेटा दिखाते हैं और उपयोगकर्ता से ऑब्जेक्ट के अनावश्यक विवरण "छुपाएं" दिखाते हैं। अपने मोबाइल फोन पर विचार करें, आपको सिर्फ यह जानने की जरूरत है कि संदेश भेजने या कॉल करने के लिए कौन से बटन दबाए जाएंगे, जब आप बटन दबाते हैं, आपके संदेश कैसे भेजे जाते हैं, आपकी कॉल कैसे जुड़ी होती हैं, तो यह सब कुछ दूर है उपयोगकर्ता।

Encapsulation कक्षा और नामक एक इकाई में डेटा और कार्यों के संयोजन की प्रक्रिया है। Encapsulation में, डेटा सीधे उपयोग नहीं किया जाता है; यह कक्षा के अंदर मौजूद कार्यों के माध्यम से पहुंचा जा सकता है। सरल शब्दों में, कक्षा के गुण निजी और सार्वजनिक गेटटर रखा जाता है और इन विशेषताओं में हेरफेर करने के लिए सेटर विधियां प्रदान की जाती हैं। इस प्रकार, encapsulation डेटा छुपा डेटा की अवधारणा बनाता है।


अमूर्त सामान्यीकृत शब्द है। यानी Encapsulation Abstraction का सबसेट है।

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

उदाहरण के लिए, एक कार स्वयं एक अच्छी तरह से परिभाषित वस्तु है, जो एक अन्य गियरिंग सिस्टम, स्टीयरिंग तंत्र, इंजन जैसी कई छोटी वस्तुओं से बना है, जिनके पास फिर से अपने स्वयं के उपप्रणाली हैं। लेकिन इंसानों के लिए कार एक ही वस्तु है, जिसे इसके उपप्रणाली की मदद से प्रबंधित किया जा सकता है, भले ही उनके आंतरिक विवरण अज्ञात हों। Courtesy

Encapsulation: एक सदस्य (यानी कक्षा) में डेटा सदस्य और विधि को एक साथ लपेटना Encapsulation कहा जाता है।

Encapsulation एक कैप्सूल में संलग्न की तरह है। वह उस ऑब्जेक्ट में किसी ऑब्जेक्ट से संबंधित संबंधित संचालन और डेटा को संलग्न कर रहा है।

Encapsulation आपके बैग की तरह है जिसमें आप अपनी कलम, किताब इत्यादि रख सकते हैं। इसका मतलब है कि यह सदस्यों और कार्यों को encapsulating की संपत्ति है।

class Bag{
    book;
    pen;
    ReadBook();
}

Encapsulation का मतलब है किसी ऑब्जेक्ट के आंतरिक विवरण छुपाएं, यानी कोई वस्तु कुछ कैसे करती है।

Encapsulation ग्राहकों को अपने अंदरूनी दृश्य देखने से रोकता है, जहां अमूर्तता का व्यवहार लागू किया जाता है।

Encapsulation एक ऑब्जेक्ट में किसी ऑब्जेक्ट में किसी ऑब्जेक्ट में जानकारी की सुरक्षा के लिए उपयोग की जाने वाली तकनीक है।

सुरक्षा के लिए डेटा छुपाएं जैसे चर को निजी बनाना, और निजी डेटा तक पहुंचने के लिए संपत्ति का पर्दाफाश करना जो सार्वजनिक होगा।

इसलिए, जब आप संपत्ति तक पहुंचते हैं तो आप डेटा को सत्यापित कर सकते हैं और इसे सेट कर सकते हैं। Courtesy


एनकैपलेशन यह है कि यह किस तरह लगता है, इसकी सामग्री को सुरक्षित रखने के लिए किसी चीज के चारों ओर एक बॉक्स डालने का एक तरीका है। एब्स्ट्रक्शन कुछ के कार्यात्मक गुणों को निकालने वाला है जैसे कि आप केवल आंतरिक कार्यकलापों के ज्ञान के बिना निकाले गए कार्यों का उपयोग करके संचालन कर सकते हैं।

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

एस्ट्रस्ट्रक्शन में वास्तव में विरासत के साथ कुछ भी नहीं है। आप "धातु" जैसे एक और अमूर्त हो सकते हैं जो पदार्थों के गुणों को अलग तरीके से निकालता है।

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

एक फंक्चर उस चीज़ पर एक अमूर्त है जिसमें मानचित्र की कुछ धारणा है, यानी, आप अपनी आंतरिक सामग्री पर एक फ़ंक्शन चला सकते हैं जो आंतरिक बिट को किसी और चीज में बदल देता है। बाहरी कुछ एक ही तरह की चीज रहता है।

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

हास्केल जैसी कार्यात्मक भाषाओं में अमूर्तता की कुछ वास्तव में महान शक्तियां होती हैं जो चरम कोड को व्यावहारिक बनाती हैं।


खैर मैं एक असली दुनिया के उदाहरण के साथ अमूर्तता समझाऊंगा। अपने घर में कहें कि आपके पास एक इलेक्ट्रिक प्लग है और कई डिवाइस एक ही प्लग से कनेक्ट हो सकते हैं लेकिन प्लग को कभी भी यह नहीं पता होगा कि यह किस डिवाइस से जुड़ा हुआ है, दूसरे शब्दों में, डिवाइस के विवरण प्लग में सारणित (छिपा हुआ) है।

सोचें कि क्या हम किसी डिवाइस को सीधे प्लग के बिना बिजली के तार से कनेक्ट करते हैं? बल्ब को सीधे एक तार से कनेक्ट करें, फिर तार जानता है कि यह किस डिवाइस से जुड़ा हुआ है और जब हमें बल्ब को प्रतिस्थापित करने की आवश्यकता होती है तो हमें बल्ब से वायर कनेक्शन को हटाना होगा, जिसका अर्थ है कि बल्ब तार के साथ कसकर जोड़ता है। दूसरे शब्दों में बल्ब और तार उन विवरणों को जानता है जहां से यह जुड़ा हुआ है, इसका मतलब सारणित नहीं है।

ऑब्जेक्ट ओरिएंटेड वर्ल्ड एब्स्ट्रक्शन में बिल्कुल वही काम करता है। कक्षा जो अन्य वर्गों के कार्य / संपत्ति का उपभोग करती है उसे यह जानने की आवश्यकता नहीं है कि कौन से वर्ग कार्य / संपत्ति का उपभोग हो रहा है और सब कुछ एक इंटरफेस / अमूर्त वर्ग के साथ सारणित किया जाना चाहिए।

मुझे एक ही उदाहरण कोड करने दें। यहां मेरे पास एक वर्ग "इलेक्ट्रिकप्लग" है, जो एक डिवाइस चला रहा है। लेकिन "इलेक्ट्रिकप्लग" वर्ग में कोई विचार नहीं है कि यह कौन सा डिवाइस चल रहा है। यह इंटरफ़ेस "IDevice" को लागू करने वाला कोई भी वर्ग हो सकता है, जिसका अर्थ है "RunDevice" का कार्यान्वयन "ElectricPlug" से है। यहां पूर्ण नमूना कोड है,

class Program
{
    static void Main(string[] args)
    {
        ElectricPlug electricPlug = new ElectricPlug(new Bulb());
    }
}

public class ElectricPlug
{
    private readonly IDevice _device;
    public ElectricPlug(IDevice device)
    {
        _device = device;
    }

    public void Run()
    {
        _device.Rundevice();
    }
}


public interface IDevice
{
    void Rundevice();
}


public class Bulb : IDevice
{
    public void Rundevice()
    {
       Console.WriteLine("Switched on bulb");
    }
}

public abstract class Draw {
    public abstract void drawShape(); // this is abstraction.  Implementation detail need not to be known.
    // so we are providing only necessary detail by giving drawShape(); No implementation. Subclass will give detail.


    private int type;    // this variable cannot be set outside of the class. Because it is private.
    // Binding private instance variable with public setter/getter method is encapsulation 

    public int getType() { 
        return type;
    }

    public void setType(int type) {  // this is encapsulation. Protecting any value to be set.
        if (type >= 0 && type <= 3) {
            this.type = type;
        } else {
            System.out.println("We have four types only. Enter value between 0 to 4");
            try {
                throw new MyInvalidValueSetException();
            } catch (MyInvalidValueSetException e) {
                e.printStackTrace();
            }

        }
    }
}

Abstraction उन विधियों से संबंधित है जहां कार्यान्वयन विस्तार ज्ञात नहीं है जो एक प्रकार का कार्यान्वयन छुपा रहा है।
Encapsulation विधि के साथ उदाहरण परिवर्तनीय बाध्यकारी से संबंधित है, एक प्रकार का डेटा छुपा।


एब्स्ट्रक्शन वह प्रक्रिया है जहां आप किसी ऐसे इकाई से अनावश्यक विवरण "फेंक देते हैं" जिसे आप अपने डिज़ाइन में कैप्चर / प्रतिनिधित्व करने की योजना बनाते हैं और केवल उस डोमेन के गुणों को ही रखते हैं जो आपके डोमेन से प्रासंगिक है।
उदाहरण: कार का प्रतिनिधित्व करने के लिए आप मॉडल और मूल्य, वर्तमान स्थान और वर्तमान गति को बनाए रखेंगे और रंगों और सीटों की संख्या इत्यादि को अनदेखा करेंगे।

Encapsulation गुणों का एक "बाध्यकारी" है और संचालन जो उन्हें अबास्ट्रक्शन (अर्थात् एक वर्ग) की एक इकाई में कुशलतापूर्वक उपयोग करता है।
तो कार में accelarate stop होगा जो स्थान और वर्तमान गति इत्यादि में हेरफेर करेगा।


एनकैप्यूलेशन को डेटा को बांधने और एक इकाई के रूप में एक साथ काम करने के लिए इस्तेमाल किए जाने वाले रैपिंग पेपर के रूप में सोचा जा सकता है जो इसे सभी प्रकार की बाहरी गंदगी से बचाता है (मेरा मतलब बाहरी कार्यों) है।

सार तत्व में विवरण की अनुपस्थिति और एक जटिल प्रणाली को नियंत्रित करने के लिए एक सरल इंटरफ़ेस का उपयोग शामिल है।

उदाहरण के लिए हम अंतर्निहित विद्युत इंजीनियरिंग (एब्स्ट्रक्शन) के बारे में चिंता किए बिना बटन दबाकर बल्ब को प्रकाश डाल सकते हैं।

हालांकि आप किसी भी अन्य तरीके से बल्ब को प्रकाश नहीं दे सकते। (Encapsulation)





abstraction