जावा में OOP अवधारणाएँ

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

कैप्सूलीकरण

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

यह जावा में कैसे काम करता है:

1. फील्ड्स को निजी बनाया जाता है
2. एक वर्ग में प्रत्येक क्षेत्र को दो विशेष विधियाँ मिलती हैं: एक गेट्टर और एक सेटर। गेट्टर विधियाँ फ़ील्ड का मान लौटाती हैं। सेटर विधियाँ आपको फ़ील्ड के मान को अप्रत्यक्ष लेकिन अनुमेय तरीके से बदलने देती हैं।

जावा कोड में एनकैप्सुलेशन का उदाहरण:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John";
}
}

आपको एनकैप्सुलेशन का उपयोग क्यों करना चाहिए?

मुख्य कारण आपके कोड को बदलना आसान बनाना है। कल्पना कीजिए कि आपके पास एक हॉकी स्कूल के लिए एक आवेदन है और एक हॉकी छात्र वर्ग है जिसमें दो फ़ील्ड हैं जो छात्र का नाम और उम्र संग्रहीत करते हैं जब उसने स्कूल में दाखिला लिया था। कुछ इस तरह:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

AgeOfEnrollment फ़ील्ड सार्वजनिक है, कोई गेटर्स या सेटर नहीं है... इस वर्ग का उपयोग कई अन्य वर्गों द्वारा किया जाता है, और सब कुछ ठीक था जब तक कि कुछ डेवलपर ने निर्णय नहीं लिया कि एक एकल इंट फ़ील्ड पर्याप्त नहीं था । एक पलटन में कुछ हॉकी खिलाड़ी अपने साथियों की तुलना में लगभग एक वर्ष बड़े होते हैं, इसलिए उनके जन्म के महीने के आधार पर उन्हें दो समूहों में विभाजित करना अधिक सुविधाजनक होगा। इसलिए AgeOfEnrollment फ़ील्ड को int array (int[][]) में बदला जाना चाहिए : पहला नंबर पूर्ण वर्षों के लिए है और दूसरा महीनों के लिए है। अब आपको छात्र वर्ग का उपयोग करने वाले सभी कोड को दोबारा करने की जरूरत है! लेकिन अगर आपकी उम्र का नामांकनफ़ील्ड निजी है और आपके पास गेटर्स और सेटर्स हैं, तो सबकुछ आसान है। यदि किसी छात्र की आयु निर्धारित करने की आवश्यकता बदलती है, तो बस तर्क को setAgeOfEnrollment() सेटर विधि में अपडेट करें और आपकी कक्षाएं बिना किसी समस्या के छात्र का उपयोग जारी रख सकती हैं ! यह उदाहरण कुछ काल्पनिक है, लेकिन मुझे उम्मीद है कि यह बताता है कि एनकैप्सुलेशन का उपयोग करना एक अच्छा विचार क्यों है।

विरासत

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

यह जावा में कैसे काम करता है:

1. अभिभावक वर्ग बनाएँ।
2. विस्तृत कीवर्ड का उपयोग करके चाइल्ड क्लास बनाएँ ।
3. चाइल्ड क्लास के कंस्ट्रक्टर में, माता-पिता के क्षेत्र को सेट करने के लिए सुपर (पेरेंटफिल्ड 1, पेरेंटफिल्ड 2, ...) विधि का उपयोग करें।

कुछ नियम:

1. एक वर्ग में केवल एक अभिभावक हो सकता है।
2. एक अभिभावक वर्ग में कई बाल वर्ग हो सकते हैं।
3. एक चाइल्ड क्लास की अपनी चाइल्ड क्लास हो सकती है।

जावा कोड में विरासत का उदाहरण

चलिए एक फोन क्लास बनाते हैं।

public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}

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

जावा में वंशानुक्रम का उदाहरण

public class Android extends Phone {

// Some new fields
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {

    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}

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

बहुरूपता

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

इसका क्या मतलब है और यह जावा में कैसे काम करता है:

जावा में बहुरूपता क्या है? सामान्य तौर पर, इसका मतलब है कि आप अलग-अलग उद्देश्यों के लिए एक ही विधि नाम का उपयोग कर सकते हैं। जावा में दो प्रकार के बहुरूपता हैं: विधि ओवरराइडिंग (गतिशील बहुरूपता) और विधि अतिभार (स्थैतिक बहुरूपता)।

ओवरराइडिंग विधि

आप चाइल्ड क्लास में पेरेंट क्लास के मेथड को ओवरराइड कर सकते हैं, जिससे वह अलग तरीके से काम कर सके। आइए play() मेथड से म्यूज़िशियन पेरेंट क्लास बनाएँ।

जावा कोड में बहुरूपता का उदाहरण

public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

विभिन्न संगीतकार विभिन्न उपकरणों का उपयोग करते हैं। आइए दो बाल वर्ग बनाएं: पियानोवादक और वायलिन वादक । बहुरूपता के लिए धन्यवाद, प्रत्येक प्ले () विधि के अपने संस्करण को निष्पादित करेगा । ओवरराइड करते समय, आप @Override एनोटेशन का उपयोग कर सकते हैं, लेकिन यह आवश्यक नहीं है।

public class Pianist extends Musician {

    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}

वायलिन वादक एकल कलाकार या ऑर्केस्ट्रा का सदस्य हो सकता है। हमारे play() मेथड को ओवरराइड करते समय इसे ध्यान में रखें ।

public class Violinist extends Musician {
    boolean isSoloist;

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist)
        System.out.println("I am playing the violin solo...");
else
System.out.println("I am playing the violin in an orchestra...");

    }
}

चलिए एक डेमो क्लास बनाते हैं, जिसमें हम तीन ऑब्जेक्ट बनाएंगे, पहले बनाए गए प्रत्येक क्लास का एक उदाहरण। हम देखेंगे कि हमें क्या परिणाम मिलते हैं।

public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic");

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

यहाँ हमें क्या मिलता है:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...

हर वायलिन वादक और पियानोवादक संगीतकार होता है, लेकिन हर संगीतकार वायलिन वादक या पियानोवादक नहीं होता है। इसका अर्थ है कि यदि आपको कोई नया प्ले मेथड बनाने की आवश्यकता नहीं है, तो आप संगीतकार की प्ले विधि का उपयोग कर सकते हैं। या आप सुपर कीवर्ड का उपयोग करके माता-पिता की विधि को बच्चे से कॉल कर सकते हैं । पियानोवादक के कोड में करते हैं:

public class Pianist extends Musician {

    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}

अब डेमो क्लास में अपने main() मेथड को कॉल करते हैं। यहाँ परिणाम है:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

विधि अधिभार

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

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}

वैसे, आप इस तरह से दूसरे प्ले (बूलियन) विधि के अंदर पहली प्ले () विधि का उपयोग कर सकते हैं:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }

आइए अपने ओवरलोडिंग को प्रदर्शित करने के लिए डेमो क्लास में कुछ पंक्तियां जोड़ें:

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}

यहाँ परिणाम है:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.

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

मतिहीनता

जब हम एक वर्ग को परिभाषित करते हैं, तो हम किसी चीज का एक मॉडल बनाने की कोशिश कर रहे होते हैं। उदाहरण के लिए, मान लीजिए कि हम MyRacer नामक एक वीडियो गेम विभिन्न रेस कारों के साथ लिख रहे हैं। एक खिलाड़ी उनमें से किसी एक को चुन सकता है और बाद में इसे अपडेट कर सकता है या एक अलग खरीद सकता है। तो... कार क्या है? एक कार एक बहुत ही जटिल चीज है, लेकिन अगर हम एक रेसिंग वीडियो गेम (ड्राइविंग सिम्युलेटर के विपरीत) बनाने की कोशिश कर रहे हैं, तो हमें इसमें शामिल सभी हजारों गियर और गास्केट का वर्णन करने की आवश्यकता नहीं है। हमें इसके मॉडल, शीर्ष गति, गतिशीलता विशेषताओं, मूल्य, रंग की आवश्यकता है ... और शायद यह पर्याप्त है। यह हमारे खेल के लिए एक कार का मॉडल है। बाद में MyRacer 2 में, मान लीजिए कि हम उन टायरों को जोड़ने का निर्णय लेते हैं जो सड़क पर हैंडलिंग को प्रभावित करते हैं। यहां मॉडल अलग है, क्योंकि हमने और विवरण जोड़े हैं। होने देना' डेटा एब्स्ट्रैक्शन को किसी वस्तु की केवल महत्वपूर्ण (या आवश्यक) विशेषताओं की पहचान करने और किसी भी अप्रासंगिक विवरण की अनदेखी करने की प्रक्रिया के रूप में परिभाषित करता है। अमूर्तता के विभिन्न स्तर हैं। उदाहरण के लिए, यदि आप एक बस में यात्री हैं, तो आपको यह जानने की आवश्यकता है कि आपकी बस कैसी दिखती है और यह कहाँ जा रही है, लेकिन आपको यह जानने की आवश्यकता नहीं है कि इसे कैसे चलाना है। यदि आप एक बस चालक हैं, तो आपको यह जानने की आवश्यकता नहीं है कि नई बस कैसे बनाई जाती है - आपको केवल यह जानने की आवश्यकता है कि इसे कैसे चलाना है। लेकिन अगर आप एक बस निर्माता हैं, तो आपको अमूर्तता के निचले स्तर पर जाने की जरूरत है, क्योंकि बस के डिजाइन का विवरण आपके लिए बहुत महत्वपूर्ण है। उम्मीद है आप मेरे कथन का आशय समझ रहे होंगे। आपको यह जानने की आवश्यकता है कि आपकी बस कैसी दिखती है और यह कहाँ जा रही है, लेकिन आपको यह जानने की आवश्यकता नहीं है कि इसे कैसे चलाना है। यदि आप एक बस चालक हैं, तो आपको यह जानने की आवश्यकता नहीं है कि नई बस कैसे बनाई जाती है - आपको केवल यह जानने की आवश्यकता है कि इसे कैसे चलाना है। लेकिन अगर आप एक बस निर्माता हैं, तो आपको अमूर्तता के निचले स्तर पर जाने की जरूरत है, क्योंकि बस के डिजाइन का विवरण आपके लिए बहुत महत्वपूर्ण है। उम्मीद है आप मेरे कथन का आशय समझ रहे होंगे। आपको यह जानने की आवश्यकता है कि आपकी बस कैसी दिखती है और यह कहाँ जा रही है, लेकिन आपको यह जानने की आवश्यकता नहीं है कि इसे कैसे चलाना है। यदि आप एक बस चालक हैं, तो आपको यह जानने की आवश्यकता नहीं है कि नई बस कैसे बनाई जाती है - आपको केवल यह जानने की आवश्यकता है कि इसे कैसे चलाना है। लेकिन अगर आप एक बस निर्माता हैं, तो आपको अमूर्तता के निचले स्तर पर जाने की जरूरत है, क्योंकि बस के डिजाइन का विवरण आपके लिए बहुत महत्वपूर्ण है। उम्मीद है आप मेरे कथन का आशय समझ रहे होंगे।

यह जावा में कैसे काम करता है:

आइए जावा में अमूर्तता के चार स्तरों का निर्माण करें, या ओओपी में - निम्नतम (सबसे विशिष्ट) से उच्चतम (सबसे सार) तक।

1. अमूर्तता का निम्नतम स्तर एक विशिष्ट वस्तु है। यह एक ऐसी इकाई है जिसमें विशेषताओं का एक सेट होता है जो एक विशिष्ट वर्ग से संबंधित होता है। इसके विशिष्ट क्षेत्र मान हैं

2. ऑब्जेक्ट बनाने के लिए एक टेम्प्लेट एक क्लास है। यह समान गुणों और आंतरिक संरचना वाली वस्तुओं के समूह का विवरण है।

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

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

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

जावा कोड में एक इंटरफ़ेस का उदाहरण

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars;
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}

आप एक से अधिक इंटरफ़ेस लागू कर सकते हैं

The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}

शुरुआती छात्रों के लिए, इसमें जावा में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग की सभी मुख्य अवधारणाओं को शामिल किया गया है। 4 मुख्य OOP सिद्धांतों के अलावा, Java में जुड़ाव, एकत्रीकरण और रचना भी है। आप उन्हें "अतिरिक्त ओओपी सिद्धांत" कह सकते हैं। वे अपने अलग लेख के पात्र हैं।