डेटा एनकैप्सुलेशन और डेटा एब्स्ट्रैक्शन (Data Encapsulation और Data Abstraction)
1. डेटा एनकैप्सुलेशन (Data Encapsulation)
डेटा एनकैप्सुलेशन का मतलब है डेटा और उससे संबंधित मेथड्स (functions) को एक साथ class के अंदर बंद करना। इसे डेटा को सुरक्षित रखने और बाहरी इंटरफेस से नियंत्रण में रखने के लिए उपयोग किया जाता है। यह access modifiers (जैसे, private, protected, और public) की मदद से लागू किया जाता है।
उदाहरण:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | class EncapsulationExample { private: int data; // निजी डेटा सदस्य public: void setData(int value) { data = value; } // Setter int getData() { return data; } // Getter }; int main() { EncapsulationExample obj; obj.setData(10); // डेटा सेट करना cout << obj.getData(); // डेटा एक्सेस करना return 0; } |
C#
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | class EncapsulationExample { private int data; // निजी डेटा सदस्य public int Data { // Property का उपयोग get { return data; } set { data = value; } } } class Program { static void Main() { EncapsulationExample obj = new EncapsulationExample(); obj.Data = 10; // डेटा सेट करना Console.WriteLine(obj.Data); // डेटा एक्सेस करना } } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | class EncapsulationExample { private int data; // निजी डेटा सदस्य public void setData(int data) { this.data = data; } // Setter public int getData() { return data; } // Getter } public class Main { public static void main(String[] args) { EncapsulationExample obj = new EncapsulationExample(); obj.setData(10); // डेटा सेट करना System.out.println(obj.getData()); // डेटा एक्सेस करना } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | class EncapsulationExample: def __init__(self): self.__data = None # निजी डेटा सदस्य def set_data(self, value): self.__data = value # Setter def get_data(self): return self.__data # Getter obj = EncapsulationExample() obj.set_data(10) # डेटा सेट करना print(obj.get_data()) # डेटा एक्सेस करना |
2. डेटा एब्स्ट्रैक्शन (Data Abstraction)
डेटा एब्स्ट्रैक्शन का मतलब है केवल आवश्यक जानकारी को दिखाना और अनावश्यक विवरणों को छिपाना। यह abstract classes और interfaces की मदद से लागू किया जाता है। इसका उद्देश्य उपयोगकर्ता को कार्यान्वयन (implementation) की चिंता किए बिना आवश्यक सुविधाओं पर ध्यान केंद्रित करने देना है।
उदाहरण:
C++
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | #include <iostream> using namespace std; class AbstractExample { public: virtual void display() = 0; // Pure virtual function }; class ConcreteExample : public AbstractExample { public: void display() override { cout << "Implementation in C++" << endl; } }; int main() { AbstractExample* obj = new ConcreteExample(); obj->display(); delete obj; return 0; } |
C#
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | abstract class AbstractExample { public abstract void Display(); } class ConcreteExample : AbstractExample { public override void Display() { Console.WriteLine("Implementation in C#"); } } class Program { static void Main() { AbstractExample obj = new ConcreteExample(); obj.Display(); } } |
Java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | abstract class AbstractExample { abstract void display(); } class ConcreteExample extends AbstractExample { @Override void display() { System.out.println("Implementation in Java"); } } public class Main { public static void main(String[] args) { AbstractExample obj = new ConcreteExample(); obj.display(); } } |
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | from abc import ABC, abstractmethod class AbstractExample(ABC): @abstractmethod def display(self): pass class ConcreteExample(AbstractExample): def display(self): print("Implementation in Python") obj = ConcreteExample() obj.display() |
निष्कर्ष
डेटा एनकैप्सुलेशन डेटा को सुरक्षित रखने और एक्सेस नियंत्रण प्रदान करने पर ध्यान केंद्रित करता है, जबकि डेटा एब्स्ट्रैक्शन जटिलताओं को छिपाकर केवल प्रासंगिक सुविधाओं को दिखाने पर जोर देता है। ये दोनों सिद्धांत मॉड्यूलर और संरक्षित सॉफ़्टवेयर डिज़ाइन सुनिश्चित करने के लिए अनिवार्य हैं।
