ஜாவா கோர்க்கான சிறந்த 50 வேலை நேர்காணல் கேள்விகள் மற்றும் பதில்கள். பகுதி 1

அனைவருக்கும் வணக்கம், பெண்கள் மற்றும் தாய்மார்களே, மென்பொருள் பொறியாளர்கள்! நேர்காணல் கேள்விகளைப் பற்றி பேசலாம். நீங்கள் எதை தயார் செய்ய வேண்டும் மற்றும் நீங்கள் தெரிந்து கொள்ள வேண்டியவை பற்றி. இந்த புள்ளிகளை முதல் முறையாக மதிப்பாய்வு செய்ய அல்லது படிக்க இது ஒரு சிறந்த நேரம். OOP, ஜாவா தொடரியல், ஜாவா விதிவிலக்குகள், சேகரிப்புகள் மற்றும் மல்டித்ரெடிங் பற்றி அடிக்கடி கேட்கப்படும் கேள்விகளின் விரிவான தொகுப்பை நான் முடித்தேன், அதை நான் வசதிக்காக பல பகுதிகளாகப் பிரிப்பேன். எல்லாவற்றையும் ஒரே நேரத்தில் மறைப்பது கடினம், ஆனால் ஒரு புரோகிராமராக தங்கள் முதல் வேலையைக் கண்டுபிடிக்கத் தயாராகும் நபர்களுக்கு இந்த பொருள் ஒரு நல்ல அடித்தளத்தை வழங்கும் என்று நம்புகிறேன். சிறந்த புரிதல் மற்றும் தக்கவைப்புக்காக, மற்ற ஆதாரங்கள் மூலமாகவும் இணைக்க பரிந்துரைக்கிறேன். பல்வேறு கோணங்களில் இருந்து அணுகுவதன் மூலம் ஒரு கருத்தை ஆழமாகப் புரிந்து கொள்ள முடியும். முக்கியமான:பதிப்பு 8 க்கு முன் ஜாவாவைப் பற்றி மட்டுமே பேசுவோம். 9, 10, 11, 12 மற்றும் 13 பதிப்புகளில் வந்த அனைத்து புதுமைகளும் இங்கே கருதப்படாது. பதில்களை எவ்வாறு மேம்படுத்துவது என்பது குறித்த ஏதேனும் யோசனைகள்/கருத்துகள் வரவேற்கப்படுகின்றன . உங்கள் வாசிப்பை மகிழுங்கள். போகலாம்!

ஜாவா நேர்காணல்: OOP பற்றிய கேள்விகள்

1. ஜாவாவின் பண்புகள் என்ன?

பதில்:

1. OOP கருத்துக்கள்:

   1. பொருள் நோக்குநிலை
   2. பரம்பரை
   3. அடைப்பு
   4. பாலிமார்பிசம்
   5. சுருக்கம்

2. கிராஸ்-பிளாட்ஃபார்ம்: ஜாவா நிரலை எந்த மாற்றமும் இல்லாமல் எந்த தளத்திலும் இயக்க முடியும். நிச்சயமாக, இதற்கு நிறுவப்பட்ட JVM (ஜாவா மெய்நிகர் இயந்திரம்) தேவைப்படுகிறது.

3. உயர் செயல்திறன்: ஜஸ்ட்-இன்-டைம் (JIT) கம்பைலர் உயர் செயல்திறனை சாத்தியமாக்குகிறது. JIT கம்பைலர் பைட்கோடை இயந்திரக் குறியீடாக மாற்றுகிறது, பின்னர் JVM செயல்படுத்தத் தொடங்குகிறது.

4. மல்டித்ரெடிங்: ஜேவிஎம் செயல்படுத்தும் ஒரு நூலை உருவாக்குகிறது main thread. ஒரு புரோகிராமர் த்ரெட் வகுப்பிலிருந்து பெறப்பட்ட அல்லது Runnableஇடைமுகத்தை செயல்படுத்துவதன் மூலம் பல நூல்களை உருவாக்க முடியும்.

2. பரம்பரை என்றால் என்ன?

பரம்பரை என்பது ஒரு வகுப்பினர் மற்றொரு வகுப்பைப் பெற முடியும் ( நீட்டிக்கப்பட்ட முக்கிய சொல்லைப் பயன்படுத்தி). அதாவது, நீங்கள் பெற்ற வகுப்பிலிருந்து குறியீட்டை மீண்டும் பயன்படுத்தலாம். தற்போதுள்ள வர்க்கம் என்று அறியப்படுகிறது superclassமற்றும் புதிதாக உருவாக்கப்பட்ட வர்க்கம் subclass. பெற்றோர் மற்றும் child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

எங்கே Animalஉள்ளது parentமற்றும் Dogஉள்ளது child.

3. அடைப்பு என்றால் என்ன?

ஜாவா டெவலப்பர் பதவிகளுக்கான நேர்காணல்களில் இந்த கேள்வி அடிக்கடி கேட்கப்படுகிறது. என்காப்சுலேஷன் என்பது அணுகல் மாற்றிகள், பெறுபவர்கள் மற்றும் செட்டர்களைப் பயன்படுத்தி செயல்படுத்தலை மறைக்கிறது. டெவலப்பர்கள் தேவை என்று நினைக்கும் இடங்களில் வெளிப்புற அணுகலைத் தடுப்பதற்காக இது செய்யப்படுகிறது. நிஜ வாழ்க்கையிலிருந்து ஒரு எளிய உதாரணம் கார். எஞ்சின் செயல்பாட்டிற்கு எங்களுக்கு நேரடி அணுகல் இல்லை. நாம் செய்ய வேண்டியதெல்லாம், சாவியை பற்றவைப்பில் வைத்து இயந்திரத்தை இயக்க வேண்டும். பேட்டையின் கீழ் நடைபெறும் செயல்முறைகள் எங்கள் வணிகம் அல்ல. மேலும், எஞ்சினின் செயல்பாட்டில் நாம் தலையிட்டால், அது எதிர்பாராத சூழ்நிலைக்கு வழிவகுக்கும், ஒருவேளை காரை சேதப்படுத்தலாம் மற்றும் உடல் தீங்கு விளைவிக்கும். நிரலாக்கத்திலும் இதேதான் நடக்கும். இது விக்கிபீடியாவில் நன்றாக விவரிக்கப்பட்டுள்ளது. கோட்ஜிம்மில் இணைத்தல் பற்றிய கட்டுரையும் உள்ளது .

4. பாலிமார்பிசம் என்றால் என்ன?

பாலிமார்பிஸம் என்பது பொருளின் குறிப்பிட்ட வகை பற்றிய தகவல் இல்லாமல், அதே இடைமுகம் கொண்ட பொருட்களை அதே வழியில் கையாளும் ஒரு நிரலின் திறன் ஆகும். பழமொழி சொல்வது போல், "ஒரு இடைமுகம் - பல செயலாக்கங்கள்". பாலிமார்பிஸத்துடன், நீங்கள் பகிரப்பட்ட நடத்தைகளின் அடிப்படையில் பல்வேறு வகையான பொருட்களை ஒருங்கிணைத்து பயன்படுத்தலாம். எடுத்துக்காட்டாக, எங்களிடம் ஒரு விலங்கு வகுப்பு உள்ளது, அதில் இரண்டு சந்ததியினர் உள்ளனர்: நாய் மற்றும் பூனை. பொதுவான விலங்கு வகுப்பானது அனைவராலும் பகிரப்படும் நடத்தை, ஒலி எழுப்பும் திறன் கொண்டது. அனிமல் கிளாஸைப் பெற்ற அனைத்தையும் சேகரித்து "ஒலி உருவாக்கு" முறையைச் செயல்படுத்த வேண்டியிருக்கும் போது பாலிமார்பிக் திறன்களைப் பயன்படுத்துகிறோம். இது எப்படி இருக்கிறது என்பது இங்கே:

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

வேறு வார்த்தைகளில் கூறுவதானால், பாலிமார்பிசம் உதவியாக இருக்கும். மேலும் இது பாலிமார்பிக் (ஓவர்லோடட்) முறைகளுக்கும் பொருந்தும். பாலிமார்பிஸத்தை எவ்வாறு பயன்படுத்துவது

ஜாவா தொடரியல் பற்றிய நேர்காணல் கேள்விகள்

5. ஜாவாவில் கன்ஸ்ட்ரக்டர் என்றால் என்ன?

கட்டமைப்பாளர்கள் பின்வரும் பண்புகளைக் கொண்டுள்ளனர்:

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. 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. இடைமுகம் என்றால் என்ன?

ஜாவா பல மரபுகளை ஆதரிக்காது. இந்த வரம்பைப் போக்க, நமக்குத் தெரிந்த மற்றும் விரும்பக்கூடிய வகையில் இடைமுகங்கள் சேர்க்கப்பட்டன. இந்த பதிலின் பின்னணியில், அவற்றைப் பற்றி பேசலாம். உதாரணத்திற்கு:

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 அல்லது 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. ஆட்டோ பாக்ஸிங் மற்றும் அன்பாக்சிங்

வரலாற்று பின்னணி: ஆட்டோ பாக்ஸிங் மற்றும் அன்பாக்சிங் ஆகியவை ஜேடிகே 5 இல் உள்ள சில முக்கிய கண்டுபிடிப்புகள். ஆட்டோ பாக்ஸிங் என்பது ஒரு பழமையான வகையிலிருந்து தொடர்புடைய ரேப்பர் வகுப்பிற்கு தானாக மாற்றும் செயல்முறையாகும். அன்பாக்சிங் என்பது ஆட்டோ பாக்ஸிங்கிற்கு நேர் எதிரானது. இது ஒரு ரேப்பர் வகுப்பை ஒரு பழமையானதாக மாற்றும் செயல்முறையாகும். ஆனால் ஒரு ரேப்பரின் மதிப்பு என்றால் null, அன் NullPointerExceptionபாக்ஸிங் செய்யும் போது a எறியப்படும்.

பழமையான மற்றும் அவற்றுடன் தொடர்புடைய ரேப்பர்கள்

// ஆட்டோ பாக்ஸிங் நடக்கிறது:

• ரேப்பர் வகுப்பிற்கான குறிப்புக்கு ஒரு பழமையானதை ஒதுக்கும்போது:

  ஜாவா 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;
  }
  

// Unboxing நடக்கும்:

• ஒரு பழமையான மாறிக்கு ரேப்பர் வகுப்பின் உதாரணத்தை நாம் ஒதுக்கும்போது:

  
  // 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 இல் உள்ள ஒரு வகுப்பின் சிறந்த உதாரணம் சரம். ஒரு மாறாத வகுப்பை உருவாக்குவதற்கான முதல் படி, அதைக் குறிப்பதாகும் final, இதனால் அது நீட்டிக்கப்படுவதைத் தடுக்கிறது:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

இறுதி முறைகள்

ஒரு முறை இறுதி எனக் குறிக்கப்படும் போது, ​​அது இறுதி முறை எனப்படும் (அறிவு தருகிறதா, இல்லையா?). குழந்தை வகுப்பில் இறுதி முறையை மீற முடியாது. தற்செயலாக, ஆப்ஜெக்ட் வகுப்பின் காத்திருப்பு() மற்றும் நோட்டிஃபை() முறைகள் இறுதியானது, எனவே அவற்றை மீறும் திறன் எங்களிடம் இல்லை.

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. செயல்படுத்தல் மாறாது என்பதை உறுதிப்படுத்த இது மிகவும் முக்கியமானது.

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

மாறாதது

மாறாத பொருள்கள் என்பது பொருள் உருவாக்கப்பட்ட பிறகு அதன் நிலை மற்றும் மாறிகளை மாற்ற முடியாது. ஹாஷ்மேப்பிற்கான சிறந்த திறவுகோல், நீங்கள் நினைக்கவில்லையா? :) எடுத்துக்காட்டாக, சரம், முழு எண், இரட்டை, மற்றும் பல. உதாரணமாக:

// 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