कैप्सूलीकरण (Encapsulation)

एनकैप्सुलेशन का सार:

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

डेटा छिपाने की अनिवार्यता:

एनकैप्सुलेशन के बिना, सार्वजनिक क्षेत्र किसी भी समय दुष्ट या लापरवाह क्लाइंट कोड द्वारा दूषित हो सकते हैं:

// खतरनाक अनकैप्सुलेटेड कोड:
वर्ग बैंक खाता {
    सार्वजनिक दोहरा संतुलन; // सार्वजनिक भेद्यता!
}
// क्लाइंट कोड निष्पादित कर सकता है:
BankAccount acc = new BankAccount();
एसीसी.बैलेंस = -50000.0; // व्यावसायिक अखंडता को भ्रष्ट करता है!

बैलेंस को निजी घोषित करके और सभी अपडेट को सार्वजनिक डिपॉजिट() या निकासी() विधि के माध्यम से प्रसारित करके, वर्ग सख्त सत्यापन नियमों को लागू करता है (उदाहरण के लिए, नकारात्मक मात्रा और ओवरड्राफ्ट को अस्वीकार करना)।

जावा में चार एक्सेस स्तर:

नियंत्रित पढ़ने/लिखने के प्रोटोकॉल:

एक अच्छी तरह से संपुटित वर्ग JavaBeans नामकरण परंपराओं का पालन करते हुए मानकीकृत एक्सेसर (गेटर) और म्यूटेटर (सेटर) विधियों के माध्यम से अपनी निजी स्थिति को उजागर करता है:

• गेट्टर विधि: निजी क्षेत्र का मान लौटाने वाली एक शुद्ध सार्वजनिक विधि (उदाहरण के लिए, public int getAge() {वापसी आयु; }).
• सेटर विधि: एक अशुद्ध सार्वजनिक विधि जो एक नया मान प्राप्त करती है, इसे मान्य करती है, और निजी फ़ील्ड को अद्यतन करती है (उदाहरण के लिए, सार्वजनिक शून्य सेटएज (int आयु) { यदि (आयु > 0) यह.आयु = आयु; }).
• केवल पढ़ने योग्य कक्षाएं: अपरिवर्तनीय ऑब्जेक्ट बनाने के लिए सभी सेटर विधियों को छोड़ दें जिनकी स्थिति कंस्ट्रक्टर आरंभीकरण के बाद उत्परिवर्तित नहीं की जा सकती।
• केवल-लिखें कक्षाएं: गेटर विधियों को छोड़ दें (उदाहरण के लिए, सुरक्षित पासवर्ड प्रविष्टि के लिए)।

एब्स्ट्रैक्शन बनाम एनकैप्सुलेशन:

उपयोगकर्ता-परिभाषित पैकेज बनाना और उपयोग करना:

एक पैकेज एक नामकरण तंत्र और एक भौतिक निर्देशिका संरचना दोनों है। किसी क्लास को पैकेज में रखने के लिए, package स्टेटमेंट स्रोत फ़ाइल में सबसे पहली गैर-टिप्पणी पंक्ति होनी चाहिए:

पैकेज com.targetexams.school; // पंक्ति 1: पहला कथन होना चाहिए!

पब्लिक क्लास रिपोर्टकार्ड {
    // कक्षा कार्यान्वयन
}

आयात पैकेज:

बाहरी कक्षाएं आयात कीवर्ड का उपयोग करके पैकेज्ड कक्षाओं तक पहुंचती हैं:

• import java.util.Scanner; (विशिष्ट वर्ग आयात - इष्टतम प्रदर्शन और शून्य नामकरण अस्पष्टता)।
• import java.util.*; (वाइल्डकार्ड आयात - पैकेज में सभी वर्गों को आयात करता है, लेकिन उप-पैकेज को नहीं)।

तीन मुख्य इंजीनियरिंग लाभ:

1. मॉड्यूलैरिटी और रख-रखाव: एक इनकैप्सुलेटेड क्लास के स्रोत कोड को बाहरी कॉलिंग कोड को तोड़े बिना पूरी तरह से फिर से लिखा जा सकता है (उदाहरण के लिए, एक सरणी से डेटाबेस बैकएंड पर स्विच करना), बशर्ते सार्वजनिक विधि हस्ताक्षर अपरिवर्तित रहें।
2. सुरक्षा और मजबूती: आंतरिक स्थिति को अनधिकृत बाहरी संशोधन के माध्यम से अमान्य या भ्रष्ट स्थिति में नहीं रखा जा सकता है।
3. ढीला युग्मन और उच्च सामंजस्य: कक्षाएं अच्छी तरह से परिभाषित सार्वजनिक संचार अनुबंधों के साथ स्वतंत्र घटक बनी रहती हैं।

मॉडल प्रोग्राम 1: डेटा सत्यापन के साथ पूरी तरह से एन्क्रिप्टेड बैंक खाता

पब्लिक क्लास बैंकखाता {
    // 1. निजी डेटा सदस्य (डेटा छिपाना)
    निजी स्ट्रिंग खाता संख्या;
    निजी स्ट्रिंग खाताधारक;
    निजी दोहरा संतुलन;

    // 2. पैरामीटरयुक्त कंस्ट्रक्टर
    सार्वजनिक बैंक खाता (स्ट्रिंग खाता संख्या, स्ट्रिंग धारक, डबल प्रारंभिक जमा) {
        this.accountNumber = accNo;
        this.accountHolder = धारक;
        यदि (प्रारंभिक जमा >= 500.0) {
            यह.शेष = प्रारंभिक जमा;
        }अन्यथा{
            System.out.println('चेतावनी: न्यूनतम प्रारंभिक जमा राशि 500 रुपये है। शेष राशि 500.0 पर सेट है।');
            यह.शेष = 500.0;
        }
    }

    // 3. गेटर मेथड्स (एक्सेसर्स)
    सार्वजनिक स्ट्रिंग getAccountNumber() { रिटर्न अकाउंटनंबर; }
    सार्वजनिक स्ट्रिंग getAccountHolder() { रिटर्न अकाउंटहोल्डर; }
    सार्वजनिक डबल गेटबैलेंस() { रिटर्न बैलेंस; }

    // 4. सख्त संपुटित व्यावसायिक नियमों के साथ उत्परिवर्तक विधियाँ
    सार्वजनिक शून्य जमा (दोगुनी राशि) {
        यदि (राशि > 0) {
            शेष += राशि;
            System.out.println("रु. " + राशि + " सफलतापूर्वक जमा किया गया। अद्यतन शेष: रु. " + शेष);
        }अन्यथा{
            System.out.println ("त्रुटि: जमा राशि सख्ती से सकारात्मक होनी चाहिए!");
        }
    }

    सार्वजनिक शून्य निकासी (दोगुनी राशि) {
        यदि (राशि <= 0) {
            System.out.println("Error: Withdrawal amount must be positive!");
        } else if (balance - amount < 500.0) {
            System.out.println("Error: Insufficient funds! Minimum balance of Rs. 500 must be retained.");
        } else {
            balance -= amount;
            System.out.println("Rs. " + amount + " withdrawn successfully. Remaining Balance: Rs. " + balance);
        }
    }

    public static void main(String[] args) {
        BankAccount acc = new BankAccount("SB-10294", "Pooja Hegde", 15000.0);
        acc.deposit(5000.0);
        acc.withdraw(18000.0); // Rejected due to minimum balance rule!
        acc.withdraw(8000.0);  // Accepted
    }
}

मॉडल प्रोग्राम 2: वेतन गणना के साथ संक्षिप्त कर्मचारी वर्ग

सार्वजनिक वर्ग कर्मचारी वेतन {
    निजी इंट पैन;
    निजी स्ट्रिंग नाम;
    निजी दोहरा करआय;
    निजी दोहरा कर;

    सार्वजनिक शून्य इनपुटइन्फो (इंट पैन, स्ट्रिंग नाम, डबल टैक्सइनकम) {
        यह.पैन = पैन;
        यह.नाम = नाम;
        this.taxIncome = करआय;
    }

    सार्वजनिक शून्य कैलटैक्स() {
        यदि (करआय <= 250000) {
            tax = 0.0;
        } else if (taxIncome <= 500000) {
            tax = (taxIncome - 250000) * 0.10;
        } else if (taxIncome <= 1000000) {
            tax = (250000 * 0.10) + ((taxIncome - 500000) * 0.20);
        } else {
            tax = (250000 * 0.10) + (500000 * 0.20) + ((taxIncome - 1000000) * 0.30);
        }
    }

    public void displayInfo() {
        System.out.println("Pan Number	Name		Taxable Income	Tax Payable");
        System.out.println(pan + "		" + name + "		Rs. " + taxIncome + "	Rs. " + tax);
    }

    public static void main(String[] args) {
        EmployeeSalary emp = new EmployeeSalary();
        emp.inputInfo(1092837, "Rajesh Kumar", 750000.0);
        emp.calTax();
        emp.displayInfo();
    }
}