
ஜாவா நேர்காணல்: OOP பற்றிய கேள்விகள்
1. ஜாவாவின் பண்புகள் என்ன?
பதில்:-
OOP கருத்துக்கள்:
- பொருள் நோக்குநிலை
- பரம்பரை
- அடைப்பு
- பாலிமார்பிசம்
- சுருக்கம்
-
கிராஸ்-பிளாட்ஃபார்ம்: ஜாவா நிரலை எந்த மாற்றமும் இல்லாமல் எந்த தளத்திலும் இயக்க முடியும். நிச்சயமாக, இதற்கு நிறுவப்பட்ட JVM (ஜாவா மெய்நிகர் இயந்திரம்) தேவைப்படுகிறது.
-
உயர் செயல்திறன்: ஜஸ்ட்-இன்-டைம் (JIT) கம்பைலர் உயர் செயல்திறனை சாத்தியமாக்குகிறது. JIT கம்பைலர் பைட்கோடை இயந்திரக் குறியீடாக மாற்றுகிறது, பின்னர் JVM செயல்படுத்தத் தொடங்குகிறது.
- மல்டித்ரெடிங்: ஜேவிஎம் செயல்படுத்தும் ஒரு நூலை உருவாக்குகிறது
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. ஜாவாவில் கன்ஸ்ட்ரக்டர் என்றால் என்ன?
கட்டமைப்பாளர்கள் பின்வரும் பண்புகளைக் கொண்டுள்ளனர்:- ஒரு புதிய பொருள் உருவாக்கப்படும் போது, நிரல் அதை உருவாக்க பொருத்தமான கட்டமைப்பாளரைப் பயன்படுத்துகிறது.
- ஒரு கட்டமைப்பாளர் ஒரு முறை போன்றது. அதன் தனித்துவமான அம்சங்கள், திரும்பப்பெறும் மதிப்பு இல்லை (வெற்றும் உட்பட) மற்றும் அதன் பெயர் வகுப்பின் பெயரைப் போலவே உள்ளது.
- எந்தவொரு கன்ஸ்ட்ரக்டரும் வெளிப்படையாக உருவாக்கப்படவில்லை என்றால், ஒரு வெற்று கட்டமைப்பாளர் தானாகவே உருவாக்கப்படும்.
- ஒரு கட்டமைப்பாளர் மேலெழுதப்படலாம்.
- அளவுருக்கள் கொண்ட ஒரு கட்டமைப்பாளரை நீங்கள் அறிவித்தாலும், அளவுருக்கள் இல்லாத ஒன்று தேவைப்பட்டால், அதை நீங்கள் தனித்தனியாக உருவாக்க வேண்டும், ஏனெனில் அது தானாகவே உருவாக்கப்படாது.
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. அணுகல் மாற்றிகள் என்றால் என்ன?
அணுகல் மாற்றிகள் என்பது வகுப்புகள், முறைகள் மற்றும் மாறிகளுக்கான அணுகலைத் தனிப்பயனாக்குவதற்கான ஒரு பொறிமுறையாகும். பின்வரும் மாற்றிகள் உள்ளன, அணுகலை அதிகரிக்கும் வரிசையில் பட்டியலிடப்பட்டுள்ளன:private
— இந்த அணுகல் மாற்றியானது முறைகள், புலங்கள் மற்றும் கட்டமைப்பாளர்களில் பயன்படுத்தப்படுகிறது. அவர்கள் அறிவிக்கப்பட்ட வகுப்பிற்கு மட்டுமே அணுகல் உள்ளது.package-private (default)
— இது வகுப்புகளுக்கான இயல்புநிலை அணுகல் நிலை. கிளாஸ், மெத்தட், மாறி அல்லது கன்ஸ்ட்ரக்டர் அறிவிக்கப்பட்ட குறிப்பிட்ட தொகுப்பிற்கு மட்டுமே அணுகல் இருக்கும்.protected
package-private
— இந்த அணுகல் மாற்றியானது , மாற்றியமைப்புடன் ஒரு வகுப்பைப் பெறுகின்ற வகுப்புகளுக்கான அணுகலைச் சேர்ப்பது போன்ற அதே அணுகல் நிலையை வழங்குகிறதுprotected
.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()
A
fooB()
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];
இந்த தொடரியல் மூலம் பல முடிவுகளை எடுக்கலாம்:
- ஒரு வரிசை அறிவிக்கப்படும் போது, அதன் வகை அறியப்படுகிறது. வகை தெரிந்தால், வரிசையில் உள்ள ஒவ்வொரு கலத்தின் அளவும் தெரியும்.
- முழு வரிசையின் அளவு அறியப்படுகிறது.
வரிசைப்பட்டியலில் உள்ள பொருட்களை அணுகும் போது O(1)ஐ எவ்வாறு அடைவது?
இந்தக் கேள்வி உடனடியாக முந்தையதைத் தொடர்ந்து வருகிறது. உண்மை என்னவென்றால், பழமையானவற்றை வைத்திருக்கும் ஒரு வரிசையுடன் பணிபுரியும் போது, நாம் முன்கூட்டியே (உருவாக்கும் நேரத்தில்) உறுப்பு வகையின் அளவை அறிவோம். ஆனால் இந்த வகையான பரம்பரை படிநிலை இருந்தால் நாம் என்ன செய்வோம் மற்றும்
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
சொல்லை மாறிகள், முறைகள் மற்றும் வகுப்புகளில் பயன்படுத்தலாம்.
- இறுதி மாறியின் மதிப்பை துவக்கிய பிறகு மாற்ற முடியாது.
- ஒரு இறுதி வகுப்பு மலட்டுத்தன்மை கொண்டது :) அது குழந்தைகளைப் பெற முடியாது.
- ஒரு இறுதி முறையை ஒரு வழித்தோன்றல் மேலெழுத முடியாது.
இறுதி மாறிகள்
ஜாவா ஒரு மாறியை அறிவிக்கவும் அதற்கு மதிப்பை ஒதுக்கவும் இரண்டு வழிகளை வழங்குகிறது:- நீங்கள் ஒரு மாறியை அறிவித்து பின்னர் அதை துவக்கலாம்.
- நீங்கள் ஒரு மாறியை அறிவித்து உடனடியாக மதிப்பை ஒதுக்கலாம்.
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
நீட்டிக்க முடியாது என அறிவிக்கப்பட்டது. இன்னும் எளிமையாகச் சொன்னால், வேறு எந்த வகுப்பினரும் இதைப் பெற முடியாது. final
JDK இல் உள்ள ஒரு வகுப்பின் சிறந்த உதாரணம் சரம். ஒரு மாறாத வகுப்பை உருவாக்குவதற்கான முதல் படி, அதைக் குறிப்பதாகும் 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
GO TO FULL VERSION