जावा कोअरसाठी शीर्ष 50 जॉब इंटरव्ह्यू प्रश्न आणि उत्तरे. भाग 1

सर्वांना नमस्कार, स्त्रिया आणि सज्जन, सॉफ्टवेअर अभियंते! चला मुलाखतीच्या प्रश्नांबद्दल बोलूया. आपल्याला कशाची तयारी करायची आहे आणि आपल्याला काय माहित असणे आवश्यक आहे याबद्दल. प्रथमच या मुद्द्यांचे पुनरावलोकन करण्यासाठी किंवा अभ्यास करण्यासाठी ही उत्तम वेळ आहे. मी ओओपी, जावा सिंटॅक्स, जावा अपवाद, संग्रह आणि मल्टीथ्रेडिंग बद्दल वारंवार विचारल्या जाणार्‍या प्रश्नांचा एक विस्तृत संग्रह संपवला, ज्याला मी सोयीसाठी अनेक भागांमध्ये विभाजित करेन. एकाच वेळी सर्वकाही कव्हर करणे कठीण आहे, परंतु मला आशा आहे की ही सामग्री प्रोग्रामर म्हणून त्यांची पहिली नोकरी शोधण्याची तयारी करणाऱ्यांसाठी एक चांगला पाया देईल. सर्वोत्कृष्ट समज आणि ठेवण्यासाठी, मी इतर स्त्रोतांद्वारे देखील कंघी करण्याचा सल्ला देतो. एखाद्या संकल्पनेकडे अनेक वेगवेगळ्या कोनातून संपर्क साधून तुम्ही त्याचे सखोल आकलन करू शकता. महत्त्वाचे:आम्ही फक्त आवृत्ती 8 च्या आधी Java बद्दल बोलणार आहोत. 9, 10, 11, 12 आणि 13 या आवृत्तीमध्ये आलेल्या सर्व नवकल्पनांचा येथे विचार केला जाणार नाही. उत्तरे कशी सुधारायची यावरील कोणत्याही कल्पना/टिप्पण्यांचे स्वागत आहे . तुमच्या वाचनाचा आनंद घ्या. चल जाऊया!

जावा मुलाखत: OOP बद्दल प्रश्न

1. Java ची वैशिष्ट्ये काय आहेत?

उत्तर:

1. OOP संकल्पना:

   1. ऑब्जेक्ट अभिमुखता
   2. वारसा
   3. encapsulation
   4. बहुरूपता
   5. अमूर्तता

2. क्रॉस-प्लॅटफॉर्म: जावा प्रोग्राम कोणत्याही प्लॅटफॉर्मवर कोणताही बदल न करता चालवला जाऊ शकतो. अर्थात, यासाठी स्थापित JVM (जावा व्हर्च्युअल मशीन) आवश्यक आहे.

3. उच्च कार्यक्षमता: जस्ट-इन-टाइम (JIT) कंपाइलर उच्च कार्यप्रदर्शन शक्य करते. JIT कंपाइलर बायटेकोडला मशीन कोडमध्ये रूपांतरित करतो आणि नंतर JVM अंमलबजावणी सुरू करतो.

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. encapsulation म्हणजे काय?

जावा डेव्हलपर पदांसाठी मुलाखतींमध्ये हा प्रश्न अनेकदा विचारला जातो. एन्कॅप्सुलेशन ऍक्सेस मॉडिफायर्स, गेटर्स आणि सेटर वापरून अंमलबजावणी लपवत आहे. विकासकांना जेथे आवश्यक वाटते तेथे बाह्य प्रवेशास प्रतिबंध करण्यासाठी हे केले जाते. वास्तविक जीवनातील एक साधे उदाहरण म्हणजे कार. आम्हाला इंजिनच्या ऑपरेशनमध्ये थेट प्रवेश नाही. आपल्याला फक्त इग्निशनमध्ये की ठेवण्याची आणि इंजिन चालू करण्याची आवश्यकता आहे. हुड अंतर्गत घडणाऱ्या प्रक्रिया आमच्या कोणत्याही व्यवसाय नाही. शिवाय, जर आपण इंजिनच्या क्रियाकलापात व्यत्यय आणला तर, यामुळे एक अप्रत्याशित परिस्थिती उद्भवू शकते, शक्यतो कारचे नुकसान होऊ शकते आणि परिणामी शारीरिक हानी होऊ शकते. प्रोग्रामिंगमध्ये नेमके हेच घडते. हे विकिपीडियावर चांगले वर्णन केले आहे. CodeGym वर encapsulation बद्दल एक लेख देखील आहे .

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. स्थानिक व्हेरिएबल काय आहे?

जावा विकसकांसाठी हा आणखी एक लोकप्रिय मुलाखत प्रश्न आहे. लोकल व्हेरिएबल हे एक व्हेरिएबल आहे जे एका पद्धतीमध्ये परिभाषित केले जाते आणि जोपर्यंत पद्धत अंमलात आणली जात आहे तोपर्यंत अस्तित्वात असते. अंमलबजावणी समाप्त होताच, स्थानिक व्हेरिएबल अस्तित्वात नाही. हा एक प्रोग्राम आहे जो main() पद्धतीमध्ये helloMessage नावाचा स्थानिक व्हेरिएबल वापरतो:

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

8. उदाहरण व्हेरिएबल काय आहे?

इन्स्टन्स व्हेरिएबल हे व्हेरिएबल आहे जे क्लासमध्ये घोषित केले जाते. जोपर्यंत एखादी वस्तू अस्तित्वात आहे तोपर्यंत ती अस्तित्वात आहे. उदाहरणार्थ, आमच्याकडे बी क्लास आहे, ज्यामध्ये दोन उदाहरण व्हेरिएबल्स आहेत - nectarLoad आणि maxNectarLoad:

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. protectedpackage-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. इंटरफेस म्हणजे काय?

Java एकाधिक वारसा समर्थन देत नाही. या मर्यादेवर मात करण्यासाठी, आपल्याला माहित असलेल्या आणि आवडतात अशा इंटरफेसमध्ये जोडले गेले होते;) बर्याच काळापासून, इंटरफेसमध्ये कोणत्याही अंमलबजावणीशिवाय केवळ पद्धती होत्या. या उत्तराच्या संदर्भात, त्यांच्याबद्दल बोलूया. उदाहरणार्थ:

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. इंटरफेसमध्ये डीफॉल्ट पद्धत काय आहे?

आता डीफॉल्ट पद्धतींबद्दल बोलूया. ते कशासाठी आहेत? ते कोणासाठी आहेत? या पद्धती "दोन्ही हात" सर्व्ह करण्यासाठी जोडल्या गेल्या. मी काय बोलतोय? बरं, एकीकडे, नवीन कार्यक्षमता जोडण्याची गरज होती: lambdas आणि Stream API. दुसरीकडे, जावा कशासाठी प्रसिद्ध आहे - बॅकवर्ड कंपॅटिबिलिटी टिकवून ठेवणे आवश्यक होते. हे करण्यासाठी, इंटरफेसला काही नवीन तयार-तयार उपाय आवश्यक आहेत. अशा प्रकारे डिफॉल्ट पद्धती आमच्याकडे आल्या. डीफॉल्ट पद्धत ही इंटरफेसमध्ये लागू केलेली पद्धत आहे, जी कीवर्डसह चिन्हांकित आहे 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”;

नाव व्हेरिएबलचे मूल्य बदलताच, स्टॅकमधील मूल्य बदलते: StringBuilder सारखेच आहे StringBuffer, फक्त ते थ्रेड सुरक्षित नाही. परिणामी, ते पेक्षा लक्षणीय वेगवान आहे StringBuffer.

18. अमूर्त वर्ग आणि इंटरफेसमध्ये काय फरक आहे?

अमूर्त वर्ग:

• अ‍ॅबस्ट्रॅक्ट क्लासेसमध्ये डीफॉल्ट कन्स्ट्रक्टर असतो. प्रत्येक वेळी अमूर्त वर्गाचा वंशज तयार केला जातो.
• त्यामध्ये अमूर्त पद्धती आणि अमूर्त पद्धतींचा समावेश असू शकतो. सर्वसाधारणपणे, अमूर्त वर्गामध्ये अमूर्त पद्धती असणे आवश्यक नाही.
• ज्या वर्गाला अमूर्त वारसा मिळतो त्याने केवळ अमूर्त पद्धती लागू करणे आवश्यक आहे.
• अमूर्त वर्गात उदाहरण व्हेरिएबल्स असू शकतात (प्रश्न # 5 पहा).

इंटरफेस:

• इंटरफेसमध्ये कन्स्ट्रक्टर नसतो आणि इनिशियलाइज करता येत नाही.
• केवळ अमूर्त पद्धती जोडल्या जाऊ शकतात (डिफॉल्ट पद्धती वगळता).
• इंटरफेसची अंमलबजावणी करणाऱ्या वर्गांनी सर्व पद्धती (डिफॉल्ट पद्धती वगळता) लागू केल्या पाहिजेत.
• इंटरफेसमध्ये फक्त स्थिरांक असू शकतात.

19. अरे O(1) मधील घटक ऍक्सेस करणे का आहे?

हा प्रश्न माझ्या शेवटच्या मुलाखतीत अक्षरशः विचारला गेला होता. मी नंतर शिकलो, या प्रश्नाचा उद्देश हा आहे की एखादी व्यक्ती कशी विचार करते. स्पष्टपणे, या ज्ञानात थोडे व्यावहारिक मूल्य आहे. ते जाणून घेणे पुरेसे आहे. प्रथम, आम्हाला हे स्पष्ट करणे आवश्यक आहे की O(1) हे "स्थिर वेळ" अल्गोरिदमच्या वेळेच्या जटिलतेसाठी नोटेशन आहे. दुसऱ्या शब्दांत, हे पदनाम सर्वात जलद अंमलबजावणीची वेळ दर्शवते. या प्रश्नाचे उत्तर देण्यासाठी, आपल्याला अॅरेबद्दल काय माहित आहे याचा विचार करणे आवश्यक आहे. अॅरे तयार करण्यासाठी int, आपण खालील लिहावे:

int[] intArray = new int[100];

या वाक्यरचनेतून अनेक निष्कर्ष काढले जाऊ शकतात:

1. जेव्हा अॅरे घोषित केला जातो तेव्हा त्याचा प्रकार ओळखला जातो. जर प्रकार माहित असेल तर अॅरेमधील प्रत्येक सेलचा आकार माहित असेल.
2. संपूर्ण अॅरेचा आकार ज्ञात आहे.

त्यामुळे कोणत्या सेलवर लिहायचे हे समजून घेण्यासाठी, आपल्याला फक्त मेमरीच्या कोणत्या क्षेत्रामध्ये लिहायचे आहे याची गणना करणे आवश्यक आहे. संगणकासाठी, हे सोपे आहे. वाटप केलेली मेमरी कोठून सुरू होते, घटकांची संख्या आणि प्रत्येक सेलचा आकार संगणकाला माहीत असतो. या सर्वांचा अर्थ असा आहे की लिहिण्याची जागा अॅरेच्या सुरुवातीच्या ठिकाणाप्रमाणे असेल + प्रत्येक सेलचा आकार निर्देशांकाने गुणाकार केला जाईल.

तर अॅरेलिस्टमधील ऑब्जेक्ट्समध्ये प्रवेश करताना आपण O(1) वर कसे पोहोचू?

हा प्रश्न लगेच मागील एक अनुसरण करतो. सत्य हे आहे की प्रिमिटिव्ह धारण करणार्‍या अ‍ॅरेसोबत काम करताना, घटक प्रकाराचा आकार आम्हाला अगोदरच (निर्मितीच्या वेळी) माहित असतो. परंतु आमच्याकडे या प्रकारची वारसा श्रेणीक्रम असेल आणि आम्हाला A प्रकारातील घटकांसाठी संग्रह तयार करायचा असेल आणि भिन्न अंमलबजावणी (B, C, आणि D) जोडायची असेल तर आम्ही काय करू:

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अनबॉक्सिंग दरम्यान फेकले जाईल.

आदिम आणि त्यांच्याशी संबंधित आवरण

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

• रॅपर क्लासच्या संदर्भासाठी आदिम नियुक्त करताना:

  Java 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. अंतिम पद्धत वंशज द्वारे अधिलिखित केली जाऊ शकत नाही.

आम्ही उच्च-स्तरीय सामग्री कव्हर केली आहे. आता आणखी खोलात जाऊ या.

अंतिम चल

Java आम्हाला व्हेरिएबल घोषित करण्याचे आणि त्याला मूल्य नियुक्त करण्याचे दोन मार्ग देते:

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 मधील वर्गाचे उत्कृष्ट उदाहरण म्हणजे स्ट्रिंग. अपरिवर्तनीय वर्ग तयार करण्याची पहिली पायरी म्हणजे त्याला म्‍हणून चिन्हांकित करणे final, अशा प्रकारे ते वाढवण्‍यापासून प्रतिबंधित करणे:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

अंतिम पद्धती

जेव्हा एखादी पद्धत अंतिम म्हणून चिन्हांकित केली जाते, तेव्हा तिला अंतिम पद्धत म्हणतात (समजते, बरोबर?). बाल वर्गात अंतिम पद्धत ओव्हरराइड केली जाऊ शकत नाही. प्रसंगोपात, ऑब्जेक्ट क्लासच्या wait() आणि notify() पद्धती अंतिम आहेत, त्यामुळे आमच्याकडे त्या ओव्हरराइड करण्याची क्षमता नाही.

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

class ChildOfFinalExample extends FinalExample {

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

Java मध्ये फायनल कसे आणि कुठे वापरायचे

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

23. परिवर्तनीय आणि अपरिवर्तनीय प्रकार काय आहेत?

परिवर्तनीय

म्युटेबल ऑब्जेक्ट्स अशा वस्तू आहेत ज्यांची स्थिती आणि व्हेरिएबल्स निर्मितीनंतर बदलले जाऊ शकतात. बदलण्यायोग्य वर्गांच्या उदाहरणांमध्ये StringBuilder आणि StringBuffer यांचा समावेश होतो. उदाहरण:

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());
   }
}

अपरिवर्तनीय

अपरिवर्तनीय ऑब्जेक्ट्स हे ऑब्जेक्ट्स आहेत ज्यांची स्थिती आणि व्हेरिएबल्स ऑब्जेक्ट तयार झाल्यानंतर बदलता येत नाहीत. हॅशमॅपसाठी एक उत्तम की, तुम्हाला वाटत नाही का? :) उदाहरणार्थ, String, Integer, Double, वगैरे. उदाहरण:

// 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());

   }
}

पुढील भागात, संग्रहाविषयी प्रश्न आणि उत्तरांचा विचार करू. GitHub वर माझे प्रोफाइल जावा कोअरसाठी टॉप 50 जॉब इंटरव्ह्यू प्रश्न आणि उत्तरे. भाग 2