जावा कोर के लिए शीर्ष 50 नौकरी के साक्षात्कार प्रश्न और उत्तर। भाग ---- पहला

सभी को नमस्कार, देवियो और सज्जनो, सॉफ्टवेयर इंजीनियर! आइए साक्षात्कार प्रश्नों के बारे में बात करते हैं। आपको किस चीज की तैयारी करने की जरूरत है और आपको क्या जानने की जरूरत है। पहली बार इन बिंदुओं की समीक्षा या अध्ययन करने का यह एक अच्छा समय है। मुझे OOP, Java सिंटैक्स, Java अपवाद, संग्रह और मल्टीथ्रेडिंग के बारे में अक्सर पूछे जाने वाले प्रश्नों के एक व्यापक संग्रह के साथ समाप्त हुआ, जिसे मैं सुविधा के लिए कई भागों में विभाजित करूँगा। एक बार में सब कुछ कवर करना मुश्किल है, लेकिन मुझे आशा है कि यह सामग्री प्रोग्रामर के रूप में अपनी पहली नौकरी खोजने की तैयारी करने वालों के लिए एक अच्छी नींव प्रदान करेगी। सर्वोत्तम समझ और प्रतिधारण के लिए, मैं सलाह देता हूं कि अन्य स्रोतों से भी खोजबीन की जाए। आप किसी अवधारणा को कई अलग-अलग कोणों से देख कर उसकी गहरी समझ प्राप्त कर सकते हैं। महत्वपूर्ण:हम केवल संस्करण 8 से पहले जावा के बारे में बात करेंगे। संस्करण 9, 10, 11, 12 और 13 में आए सभी नवाचारों पर यहां विचार नहीं किया जाएगा। उत्तरों को बेहतर बनाने के बारे में किसी भी विचार/टिप्पणी का स्वागत है । अपने पढ़ने का आनंद लें। चल दर!

जावा साक्षात्कार: ओओपी के बारे में प्रश्न

1. जावा की विशेषताएँ क्या हैं?

उत्तर:

1. ओओपी अवधारणाएं:

   1. वस्तु अभिविन्यास
   2. विरासत
   3. कैप्सूलीकरण
   4. बहुरूपता
   5. मतिहीनता

2. क्रॉस-प्लेटफ़ॉर्म: जावा प्रोग्राम को बिना किसी बदलाव के किसी भी प्लेटफ़ॉर्म पर चलाया जा सकता है। बेशक, इसके लिए एक स्थापित जेवीएम (जावा वर्चुअल मशीन) की आवश्यकता होती है।

3. उच्च प्रदर्शन: जस्ट-इन-टाइम (JIT) कंपाइलर उच्च प्रदर्शन को संभव बनाता है। जेआईटी कंपाइलर बाइटकोड को मशीन कोड में परिवर्तित करता है और फिर जेवीएम निष्पादन शुरू करता है।

4. मल्टीथ्रेडिंग: JVM निष्पादन का एक थ्रेड बनाता है जिसे main thread. एक प्रोग्रामर थ्रेड क्लास से प्राप्त करके या Runnableइंटरफ़ेस को लागू करके कई थ्रेड्स बना सकता है।

2. विरासत क्या है?

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

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

कहाँ Animalहै parentऔर Dogकहाँ है child.

3. इनकैप्सुलेशन क्या है?

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

4. बहुरूपता क्या है?

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

List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());

दूसरे शब्दों में, बहुरूपता सहायक है। और यह बहुरूपी (अतिभारित) विधियों पर भी लागू होता है। बहुरूपता का उपयोग कैसे करें

जावा सिंटैक्स के बारे में साक्षात्कार प्रश्न

5. Java में कंस्ट्रक्टर क्या है?

कंस्ट्रक्टर्स में निम्नलिखित गुण होते हैं:

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

6. कौन से दो वर्ग ऑब्जेक्ट इनहेरिट नहीं करते हैं?

ट्रिक प्रश्नों से मूर्ख मत बनो - ऐसी कोई कक्षा नहीं है। सभी वर्ग वस्तु वर्ग को या तो सीधे या पूर्वजों के माध्यम से प्राप्त करते हैं!

7. स्थानीय चर क्या है?

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

public static void main(String[] args) {
   String helloMessage;
   helloMessage = "Hello, World!";
   System.out.println(helloMessage);
}

8. एक उदाहरण चर क्या है?

एक उदाहरण चर एक चर है जिसे एक वर्ग के अंदर घोषित किया जाता है। यह तब तक मौजूद है जब तक कोई वस्तु मौजूद है। उदाहरण के लिए, हमारे पास एक बी वर्ग है, जिसमें दो आवृत्ति चर हैं - अमृत लोड और मैक्स नेक्टर लोड:

public class Bee {

   /**
    * Current nectar load
    */
   private double nectarLoad;

   /**
    * Maximum nectar that can the bee can collect.
    */
   private double maxNectarLoad = 20.0;
 
  ...
}

9. एक्सेस संशोधक क्या हैं?

एक्सेस संशोधक कक्षाओं, विधियों और चरों तक पहुंच को अनुकूलित करने के लिए एक तंत्र है। पहुँच बढ़ाने के क्रम में सूचीबद्ध निम्नलिखित संशोधक मौजूद हैं:

1. private- इस एक्सेस मॉडिफायर का इस्तेमाल मेथड्स, फील्ड्स और कंस्ट्रक्टर्स पर किया जाता है। पहुंच उस वर्ग तक सीमित है जिसमें उन्हें घोषित किया गया है।
2. package-private (default)- यह कक्षाओं के लिए डिफ़ॉल्ट पहुंच स्तर है। पहुँच विशिष्ट पैकेज तक सीमित है जिसमें एक वर्ग, विधि, चर या निर्माणकर्ता घोषित किया जाता है।
3. protected- यह एक्सेस संशोधक समान पहुंच स्तर प्रदान करता है, जो संशोधक package-privateके साथ एक वर्ग को इनहेरिट करने वाली कक्षाओं के लिए पहुंच के अतिरिक्त है ।protected
4. public— इस पहुँच स्तर का उपयोग कक्षाओं के लिए भी किया जाता है। इस पहुँच स्तर का अर्थ है कि पूरे अनुप्रयोग में पूर्ण पहुँच है।

10. मेथड ओवरराइडिंग क्या है?

हम तरीकों को ओवरराइड करते हैं जब कोई चाइल्ड क्लास अपने पैरेंट क्लास के व्यवहार को बदलना चाहता है। अगर हमें भी वही करना है जो पेरेंट मेथड में है, तो हम चाइल्ड में super.methodName() का उपयोग कर सकते हैं, जो पैरेंट मेथड को निष्पादित करेगा। उसके बाद हम अपना अतिरिक्त तर्क जोड़ सकते हैं। आवश्यकताएँ जिन्हें अवश्य देखा जाना चाहिए:

• विधि हस्ताक्षर समान होना चाहिए
• वापसी मूल्य समान होना चाहिए

11. मेथड सिग्नेचर क्या हैं?

एक विधि हस्ताक्षर विधि के नाम और तर्कों का संयोजन है जो विधि लेता है। ओवरलोडिंग विधियों के दौरान विधि हस्ताक्षर एक विधि का विशिष्ट पहचानकर्ता है।

12. मेथड ओवरलोडिंग क्या है?

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

• वही नाम
• अलग तर्क
• अलग-अलग रिटर्न प्रकार हो सकते हैं

उदाहरण के लिए, ArrayListवर्ग की add()विधि अतिभारित हो सकती है, जिससे हम इनपुट तर्कों के आधार पर अलग-अलग तरीकों से जोड़ सकते हैं:

• add(Object o)- यह विधि केवल एक वस्तु जोड़ती है
• add(int index, Object o)- यह विधि एक विशिष्ट सूचकांक में एक वस्तु जोड़ती है
• add(Collection<Object> c)- यह विधि वस्तुओं की एक सूची जोड़ती है
• add(int index, Collection<Object> c)- यह विधि एक विशिष्ट सूचकांक से शुरू होने वाली वस्तुओं की एक सूची जोड़ती है।

13. इंटरफ़ेस क्या है?

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

public interface Animal {
   void makeSound();
   void eat();
   void sleep();
}

कुछ विवरण इसका अनुसरण करते हैं:

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

इस कदर:

public class Cat implements Animal {
   public void makeSound() {
       // Method implementation
   }

   public void eat() {
       // Implementation
   }

   public void sleep() {
       // Implementation
   }
}

14. इंटरफ़ेस में डिफ़ॉल्ट विधि क्या है?

अब बात करते हैं डिफ़ॉल्ट तरीकों की। ये किसलिए हैं? वे किसके लिए हैं? इन विधियों को "दोनों हाथों" की सेवा के लिए जोड़ा गया था। मैं किस बारे में बात कर रहा हूं? खैर, एक ओर, नई कार्यक्षमता जोड़ने की आवश्यकता थी: लैम्ब्डा और स्ट्रीम एपीआई। दूसरी ओर, यह बनाए रखना आवश्यक था कि जावा किसके लिए प्रसिद्ध है - पश्चगामी संगतता। ऐसा करने के लिए, इंटरफेस को कुछ नए तैयार किए गए समाधानों की आवश्यकता होती है। इस तरह हमारे पास डिफ़ॉल्ट तरीके आए। एक डिफ़ॉल्ट विधि एक इंटरफ़ेस में कार्यान्वित विधि है, जिसे defaultकीवर्ड के साथ चिह्नित किया गया है। stream()उदाहरण के लिए, इंटरफ़ेस में प्रसिद्ध विधि Collection। मेरा विश्वास करो, यह इंटरफ़ेस उतना सरल नहीं है जितना लगता है। forEach()या में भी समान रूप से प्रसिद्ध विधिIterableइंटरफेस। यह तब तक मौजूद नहीं था जब तक कि डिफ़ॉल्ट तरीके नहीं जोड़े गए। वैसे, आप इसके बारे में यहां CodeGym पर भी पढ़ सकते हैं ।

15. फिर हम दो समान डिफ़ॉल्ट विधियों को कैसे प्राप्त करते हैं?

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

interface A {
   default void foo() {
       System.out.println("Foo A");
   }
}

interface B {
   default void foo() {
       System.out.println("Foo B");
   }
}

और हमारे पास एक वर्ग है जो इन दो इंटरफेस को लागू करता है। लेकिन हम इंटरफ़ेस ए या बी में एक विशिष्ट विधि कैसे चुनते हैं? निम्नलिखित विशेष निर्माण इसकी अनुमति देता है A.super.foo():

public class C implements A, B {
   public void fooA() {
       A.super.foo();
   }

   public void fooB() {
       B.super.foo();
   }
}

इस प्रकार, विधि इंटरफ़ेस की fooA()डिफ़ॉल्ट विधि का उपयोग करेगी , जबकि विधि इंटरफ़ेस की विधि का उपयोग करेगी ।foo()AfooB()foo()B

16. अमूर्त विधियाँ और वर्ग क्या हैं?

जावा में, abstractएक आरक्षित शब्द है। इसका उपयोग अमूर्त वर्गों और विधियों को निरूपित करने के लिए किया जाता है। सबसे पहले, हमें परिभाषाओं की आवश्यकता है। एक अमूर्त विधि एक ऐसी विधि है जिसे abstractसार वर्ग में कार्यान्वयन के बिना कीवर्ड का उपयोग करके घोषित किया जाता है। यही है, यह एक इंटरफ़ेस के रूप में एक तरीका है, लेकिन एक कीवर्ड के अतिरिक्त, उदाहरण के लिए:

public abstract void foo();

एक सार वर्ग एक ऐसा वर्ग है जिसे abstractकीवर्ड के साथ भी चिह्नित किया गया है:

public abstract class A {

}

एक अमूर्त वर्ग में कई विशेषताएं होती हैं:

• आप एक अमूर्त वर्ग की वस्तु नहीं बना सकते
• इसमें सार विधियां हो सकती हैं
• इसमें अमूर्त विधियाँ भी नहीं हो सकती हैं

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

17. String, StringBuilder और StringBuffer में क्या अंतर है?

Stringमान निरंतर स्ट्रिंग पूल में संग्रहीत होते हैं। जैसे ही एक स्ट्रिंग बनाई जाती है, वह इस पूल में दिखाई देती है। और आप इसे मिटा नहीं सकते। उदाहरण के लिए:

String name = "book";

चर निरंतर स्ट्रिंग पूल को इंगित करेगा नाम चर को एक अलग मान पर सेट करना, हमारे पास है:

name = "pen";

निरंतर स्ट्रिंग पूल इस तरह दिखता है: दूसरे शब्दों में, दोनों मान वहीं रहते हैं। स्ट्रिंग बफर:

• Stringमान स्टैक में संग्रहीत होते हैं। यदि कोई मान बदल जाता है, तो नया मान पुराने को बदल देगा।
• String Bufferसिंक्रनाइज़ है और इसलिए थ्रेड सुरक्षित है।
• थ्रेड सेफ्टी के कारण इसका प्रदर्शन खराब है।

उदाहरण:

StringBuffer name = “book”;

जैसे ही नाम चर का मान बदलता है, स्टैक में मान बदल जाता है: स्ट्रिंगबिल्डर बिल्कुल वैसा ही है StringBuffer, केवल यह थ्रेड सुरक्षित नहीं है। नतीजतन, यह की तुलना में काफी तेज है StringBuffer।

18. अमूर्त वर्ग और इंटरफ़ेस के बीच क्या अंतर है?

सार वर्ग:

• एब्सट्रैक्ट क्लासेस में एक डिफॉल्ट कंस्ट्रक्टर होता है। हर बार सार वर्ग का वंशज बनने पर इसे कहा जाता है।
• वे अमूर्त विधियों और गैर-अमूर्त दोनों को शामिल कर सकते हैं। सामान्य तौर पर, एक अमूर्त वर्ग के पास सार विधियाँ नहीं होती हैं।
• एक वर्ग जो एक सार को प्राप्त करता है, उसे केवल सार विधियों को लागू करना चाहिए।
• एक सार वर्ग में उदाहरण चर हो सकते हैं (प्रश्न # 5 देखें)।

इंटरफेस:

• एक इंटरफ़ेस में कोई कन्स्ट्रक्टर नहीं है और इसे प्रारंभ नहीं किया जा सकता है।
• केवल सार विधियों को जोड़ा जा सकता है (डिफ़ॉल्ट विधियों को छोड़कर)।
• इंटरफ़ेस को लागू करने वाली कक्षाओं को सभी विधियों को लागू करना चाहिए (डिफ़ॉल्ट विधियों को छोड़कर)।
• इंटरफेस में केवल स्थिरांक हो सकते हैं।

19. ऐरे O(1) में एलिमेंट को एक्सेस करना क्यों है?

यह प्रश्न सचमुच मेरे पिछले साक्षात्कार में पूछा गया था। जैसा कि मैंने बाद में सीखा, इस प्रश्न का उद्देश्य यह देखना है कि कोई व्यक्ति कैसा सोचता है। जाहिर है, इस ज्ञान का व्यावहारिक महत्व बहुत कम है। इसे जानना ही काफी है। सबसे पहले, हमें यह स्पष्ट करने की आवश्यकता है कि O(1) "निरंतर समय" एल्गोरिथम की समय जटिलता के लिए संकेतन है। दूसरे शब्दों में, यह पदनाम सबसे तेज़ निष्पादन समय इंगित करता है। इस प्रश्न का उत्तर देने के लिए, हमें यह विचार करने की आवश्यकता है कि हम सरणियों के बारे में क्या जानते हैं। एक सरणी बनाने के लिए int, हमें निम्नलिखित लिखना होगा:

int[] intArray = new int[100];

इस सिंटैक्स से कई निष्कर्ष निकाले जा सकते हैं:

1. जब एक सरणी घोषित की जाती है, तो इसका प्रकार ज्ञात होता है। यदि प्रकार ज्ञात है, तो सरणी में प्रत्येक सेल का आकार ज्ञात है।
2. संपूर्ण सरणी का आकार ज्ञात है।

इसलिए यह इस प्रकार है कि यह समझने के लिए कि किस सेल को लिखना है, हमें केवल मेमोरी के किस क्षेत्र को लिखने की गणना करने की आवश्यकता है। कंप्यूटर के लिए, यह आसान है। कंप्यूटर जानता है कि आवंटित मेमोरी कहाँ से शुरू होती है, तत्वों की संख्या और प्रत्येक सेल का आकार। इसका मतलब यह है कि लिखने का स्थान सरणी के शुरुआती स्थान के बराबर होगा + इंडेक्स द्वारा गुणा किए गए प्रत्येक सेल का आकार।

तो हम ArrayList में ऑब्जेक्ट एक्सेस करते समय O (1) पर कैसे पहुँचते हैं?

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

List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());

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

21. ऑटोबॉक्सिंग और अनबॉक्सिंग

ऐतिहासिक पृष्ठभूमि: JDK 5 में ऑटोबॉक्सिंग और अनबॉक्सिंग कुछ मुख्य नवाचार हैं। ऑटोबॉक्सिंग एक आदिम प्रकार से संबंधित रैपर वर्ग में स्वचालित रूपांतरण की प्रक्रिया है। अनबॉक्सिंग ऑटोबॉक्सिंग के बिल्कुल विपरीत है। यह एक आवरण वर्ग को आदिम में परिवर्तित करने की प्रक्रिया है। लेकिन अगर एक रैपर का मूल्य है null, तो NullPointerExceptionअनबॉक्सिंग के दौरान एक फेंक दिया जाएगा।

आदिम और उनके संबंधित आवरण

// ऑटोबॉक्सिंग होती है:

• एक रैपर वर्ग के संदर्भ में एक आदिम निर्दिष्ट करते समय:

  जावा 5 से पहले:

  
  // Manual boxing (the way it was BEFORE Java 5).
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // And so on for other types
  }
  
  After Java 5:
  // Automatic boxing (the way it became in Java 5).
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // And so on for other types
  }
  

• जब एक आदिम को एक विधि के तर्क के रूप में पारित किया जाता है जो एक रैपर की अपेक्षा करता है:

  
  public void exampleOfAutoboxing() {
     long age = 3;
     setAge(age);
  }
  
  public void setAge(Long age) {
     this.age = age;
  }
  

// अनबॉक्सिंग होती है:

• जब हम एक आदिम चर के लिए एक आवरण वर्ग का उदाहरण देते हैं:

  
  // BEFORE Java 5:
  int intValue = new Integer(4).intValue();
  double doubleValue = new Double(2.3).doubleValue();
  char c = new Character((char) 3).charValue();
  boolean b = Boolean.TRUE.booleanValue();
  
  // And after JDK 5:
  int intValue = new Integer(4);
  double doubleValue = new Double(2.3);
  char c = new Character((char) 3);
  boolean b = Boolean.TRUE;
  

• अंकगणितीय संचालन के दौरान। ऑपरेशन केवल आदिम प्रकारों पर लागू होते हैं, इसलिए आदिम प्रकारों के लिए अनबॉक्सिंग आवश्यक है।

  
  // BEFORE Java 5:
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // A comparison used to require this:
  integerBox1.intValue() > integerBox2.intValue()
        
  // In Java 5
  integerBox1 > integerBox2
  

• एक रैपर वर्ग के उदाहरण को एक विधि में पास करते समय जो संबंधित आदिम लेता है:

  
  public void exampleOfAutoboxing() {
     Long age = new Long(3);
     setAge(age);
  }
  
  public void setAge(long age) {
     this.age = age;
  }
  

22. फाइनल कीवर्ड क्या है और इसका इस्तेमाल कहां किया जाता है?

कीवर्ड finalका उपयोग चर, विधियों और कक्षाओं पर किया जा सकता है।

1. अंतिम चर का मान प्रारंभ होने के बाद बदला नहीं जा सकता।
2. एक अंतिम वर्ग बाँझ है :) इसमें बच्चे नहीं हो सकते।
3. एक वंश द्वारा एक अंतिम विधि को ओवरराइड नहीं किया जा सकता है।

हमने उच्च स्तरीय सामग्री को कवर किया है। अब और गहरा गोता लगाने देता है।

अंतिम चर

जावा हमें एक वेरिएबल घोषित करने और उसके लिए एक मान निर्दिष्ट करने के दो तरीके देता है:

1. आप एक चर घोषित कर सकते हैं और इसे बाद में आरंभ कर सकते हैं।
2. आप एक चर घोषित कर सकते हैं और तुरंत एक मान निर्दिष्ट कर सकते हैं।

यहाँ एक उदाहरण दिया गया है जो अंतिम चरों के इन उपयोगों को प्रदर्शित करता है:

public class FinalExample {

   // A static final variable that is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";

   // A final variable that is not initialized, but will only work if you
   // initialize it in the constructor:
   final long creationTime;

   public FinalExample() {
       this.creationTime = System.currentTimeMillis();
   }

   public static void main(String[] args) {
       FinalExample finalExample = new FinalExample();
       System.out.println(finalExample.creationTime);

       // The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
//    FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";

       // The final Config.creationTime field cannot be accessed
//    finalExample.creationTime = 1L;
   }
}

क्या अंतिम चर को स्थिर माना जा सकता है?

चूंकि हम अंतिम चर के लिए नए मान निर्दिष्ट नहीं कर सकते हैं, ऐसा लगता है कि ये निरंतर चर हैं। लेकिन केवल पहली नज़र में: यदि चर का डेटा प्रकार है immutable, तो, हाँ, यह एक स्थिरांक है। लेकिन अगर डेटा प्रकार है mutable, यानी परिवर्तनशील है, तो एक finalचर द्वारा संदर्भित वस्तु के मूल्य को बदलने के लिए विधियों और चर का उपयोग करना संभव होगा। इस कारण इसे स्थिरांक नहीं कहा जा सकता। निम्नलिखित उदाहरण से पता चलता है कि कुछ अंतिम चर वास्तव में स्थिर हैं, जबकि अन्य नहीं हैं, क्योंकि उन्हें बदला जा सकता है।

public class FinalExample {

   // Immutable final variables
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
   final static Integer FINAL_EXAMPLE_COUNT  = 10;

   // Mutable final variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}

स्थानीय अंतिम चर

जब finalएक विधि के भीतर एक चर बनाया जाता है, तो इसे एक local finalचर कहा जाता है:

public class FinalExample {

   public static void main(String[] args) {
       // You can do this
       final int minAgeForDriveCar = 18;

       // Or you can do this, in a for-each loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

हम अंतिम कीवर्ड का उपयोग लूप के लिए बढ़ाए गए में कर सकते हैं, क्योंकि लूप के प्रत्येक पुनरावृत्ति के बाद एक नया चर बनाया जाता है। ध्यान रखें कि यह लूप के लिए सामान्य पर लागू नहीं होता है, इसलिए हमें कंपाइल-टाइम एरर मिलेगा।

// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
   System.out.println(args[i]);
}

अंतिम वर्ग

घोषित वर्ग को finalबढ़ाया नहीं जा सकता। इसे और अधिक सरलता से कहें तो कोई अन्य वर्ग इसे प्राप्त नहीं कर सकता है। finalJDK में एक वर्ग का एक उत्कृष्ट उदाहरण है String. एक अपरिवर्तनीय वर्ग बनाने के लिए पहला कदम इसे के रूप में चिह्नित करना है final, इस प्रकार इसे विस्तारित होने से रोकना है:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

अंतिम तरीके

जब किसी विधि को अंतिम रूप से चिह्नित किया जाता है, तो इसे अंतिम विधि कहा जाता है (समझ में आता है, ठीक है?) चाइल्ड क्लास में final मेथड को ओवरराइड नहीं किया जा सकता है। संयोग से, ऑब्जेक्ट क्लास की प्रतीक्षा () और सूचित () विधियाँ अंतिम हैं, इसलिए हमारे पास उन्हें ओवरराइड करने की क्षमता नहीं है।

public class FinalExample {
   public final String generateAddress() {
       return "Some address";
   }
}

class ChildOfFinalExample extends FinalExample {

   // Compilation error!
   @Override
   public String generateAddress() {
       return "My OWN Address";
   }
}

जावा में फाइनल का उपयोग कैसे और कहाँ करें

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

23. परिवर्तनशील और अपरिवर्तनीय प्रकार क्या हैं?

परिवर्तनशील

उत्परिवर्तनीय वस्तुएँ वे वस्तुएँ होती हैं जिनकी स्थिति और चर को निर्माण के बाद बदला जा सकता है। परिवर्तनीय वर्गों के उदाहरणों में स्ट्रिंगबिल्डर और स्ट्रिंगबफर शामिल हैं। उदाहरण:

public class MutableExample {

   private String address;

   public MutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // This setter can change the name field
   public void setAddress(String address) {
       this.address = address;
   }

   public static void main(String[] args) {

       MutableExample obj = new MutableExample("First address");
       System.out.println(obj.getAddress());

       // We are updating the name field, so this is a mutable object
       obj.setAddress("Updated address");
       System.out.println(obj.getAddress());
   }
}

अडिग

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

// We'll make this class final so no one can change it
public final class ImmutableExample {

   private String address;

   ImmutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // We remove the setter

   public static void main(String[] args) {

       ImmutableExample obj = new ImmutableExample("Old address");
       System.out.println(obj.getAddress());

       // There is no way to change this field, so it is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

अगले भाग में, हम संग्रहों के बारे में प्रश्नों और उत्तरों पर विचार करेंगे। गिटहब पर मेरा प्रोफाइल जावा कोर के लिए शीर्ष 50 नौकरी के साक्षात्कार प्रश्न और उत्तर। भाग 2