1. அனைத்து வகுப்புகளும் பரம்பரைObject
ஜாவாவில் உள்ள அனைத்து வகுப்புகளும் மறைமுகமாக Object
வகுப்பைப் பெறுகின்றன.
ஜாவா கோர் தேடலில் ஜாவாவில் பரம்பரை என்றால் என்ன, அது எவ்வாறு செயல்படுகிறது என்பதை பகுப்பாய்வு செய்வோம். இப்போதைக்கு, இதிலிருந்து பின்வரும் ஒரு எளிய உண்மையைப் பார்ப்போம்:
எந்த வகுப்பின் ஒரு பொருளையும் ஒரு மாறிக்கு ஒதுக்கலாம் Object
. உதாரணமாக:
குறியீடு | குறிப்பு |
---|---|
|
மாறி ஒரு பொருளின் o குறிப்பைச் சேமிக்கிறதுScanner |
|
மாறி ஒரு பொருளின் o குறிப்பைச் சேமிக்கிறதுString |
|
மாறி ஒரு பொருளின் o குறிப்பைச் சேமிக்கிறதுInteger |
|
மாறி ஒரு பொருளின் o குறிப்பைச் சேமிக்கிறதுString |
இங்குதான் நல்ல செய்தி முடிகிறது. கம்பைலர் ஒரு மாறியில் சேமிக்கப்பட்ட அசல் வகைப் பொருளைக் கண்காணிக்காதுObject
, எனவே நீங்கள் வகுப்பின் முறைகளைத் தவிர சேமிக்கப்பட்ட பொருளின் முறைகளை அழைக்க முடியாது .Object
பொருளின் அசல் வகையுடன் தொடர்புடைய முறைகளை நீங்கள் அழைக்க வேண்டும் என்றால், முதலில் அதற்கான குறிப்பை சரியான வகையின் மாறியில் சேமிக்க வேண்டும், பின்னர் அந்த மாறியில் உள்ள முறைகளை அழைக்கவும்:
குறியீடு | குறிப்பு |
---|---|
|
நிரல் தொகுக்கப்படாது. வகுப்பிற்கு முறை Object இல்லை nextInt() . |
|
இது வேலை செய்யும். இங்கு டைப்காஸ்ட் ஆபரேட்டரைப் பயன்படுத்தி ஒரு பொருளின் குறிப்பை மாறியில் சேமிக்கிறோம் . Scanner Scanner |
Object
ஸ்கேனர் மாறிக்கு நீங்கள் சென்று ஒரு மாறியை ஒதுக்க முடியாது , Object
மாறி ஒரு பொருளின் குறிப்பை சேமித்தாலும் கூட Scanner
. ஆனால் நீங்கள் ஏற்கனவே அறிந்த டைப்காஸ்ட் ஆபரேட்டரைப் பயன்படுத்தினால் இதைச் செய்யலாம் . இது அதன் பொதுவான தோற்றம்:
Type name1 = (Type) name2;
name1
ஒரு மாறியின் பெயர் எங்கே Type
, மற்றும் ஒரு பொருளின் குறிப்பைச் சேமிக்கும் மாறியின் name2
பெயர் .Object
Type
தட்டச்சு செய்தல்
மாறியின் வகையும் பொருளின் வகையும் பொருந்தவில்லை என்றால், a ClassCastException
எறியப்படும். உதாரணமாக:
குறியீடு | குறிப்பு |
---|---|
|
இயக்க நேரத்தில் ஒரு பிழை ஏற்படும்: a ClassCastException இங்கு எறியப்படும் |
ஜாவாவில் இந்தப் பிழையைத் தவிர்க்க ஒரு வழி உள்ளது: மாறியில் சேமிக்கப்பட்ட பொருளின் வகையைச் சரிபார்த்து இதைச் செய்கிறோம் :
name instanceof Type
மாறி ஒரு பொருளா என்பதை இயக்குபவர் instanceof
சரிபார்க்கிறார் .name
Type
உதாரணமாக, பல்வேறு பொருள்களின் வரிசையில் ஒரு சரத்தைக் கண்டுபிடிப்போம்:
குறியீடு | குறிப்பு |
---|---|
|
Integer ஆட்டோ பாக்ஸிங் இந்த மதிப்புகளை முறையே ஒரு , String , மற்றும் , ஆக மாற்றும் Double . பொருள்களின் வரிசையின் மீது லூப் ஆப்ஜெக்ட் என்றால் String அதை ஒரு String மாறியில் சேமி திரையில் மாறியை காட்டவும். |
2. பொதுவானவை ஏன் தோன்றின - சேகரிப்புகள்
சேகரிப்புகளுக்கு திரும்புவோம்.
ஜாவா டெவலப்பர்கள் வகுப்பை உருவாக்கியவுடன் ArrayList
, அவர்கள் அதை உலகளாவியதாக மாற்ற விரும்பினர், எனவே அது எந்த வகையான பொருளையும் சேமிக்க முடியும். Object
எனவே அவர்கள் தனிமங்களைச் சேமிக்க s இன் வரிசையைப் பயன்படுத்தினர் .
இந்த அணுகுமுறையின் பலம் என்னவென்றால், நீங்கள் சேகரிப்பில் எந்த வகையான பொருளையும் சேர்க்கலாம்.
நிச்சயமாக, பல பலவீனங்கள் உள்ளன.
குறைபாடு 1.
ஒரு தொகுப்பிலிருந்து கூறுகளை மீட்டெடுக்கும் போது ஒரு வகை மாற்று ஆபரேட்டரை எழுதுவது எப்போதும் அவசியம்:
குறியீடு | குறிப்பு |
---|---|
|
Object பொருட்களைப் பற்றிய குறிப்புகளைச் சேமிக்க ஒரு தொகுப்பை உருவாக்கவும், சேகரிப்பை எண்களால் நிரப்பவும் 10 , 20 , ... 100 ; தொகுப்பின் கூறுகளைத் தொகுத்து தட்டச்சு செய்வது அவசியம் |
குறைபாடு 2.
ஒரு சேகரிப்பில் ஒரு குறிப்பிட்ட வகை உறுப்பு உள்ளது என்பதற்கு எந்த உத்தரவாதமும் இல்லை
குறியீடு | குறிப்பு |
---|---|
|
Object பொருட்களைப் பற்றிய குறிப்புகளைச் சேமிக்க ஒரு தொகுப்பை உருவாக்கவும் Double . _ _0.0 2.5 5.0 Double Integer |
தரவு எங்கும் சேகரிப்பில் வைக்கப்படலாம்:
- மற்றொரு முறையில்
- மற்றொரு திட்டத்தில்
- ஒரு கோப்பிலிருந்து
- நெட்வொர்க் மூலம்
குறைபாடு 3.
சேகரிப்பில் உள்ள தரவு தற்செயலாக மாற்றப்படலாம்.
உங்கள் தரவு நிரப்பப்பட்ட சேகரிப்பை சில முறைகளுக்கு அனுப்பலாம். வேறொரு புரோகிராமரால் எழுதப்பட்ட அந்த முறை, அதன் தரவை உங்கள் சேகரிப்பில் சேர்க்கிறது.
சேகரிப்பின் பெயர் அதில் எந்த வகையான தரவைச் சேமிக்க முடியும் என்பதைத் தெளிவாகக் குறிப்பிடவில்லை. உங்கள் மாறிக்கு ஒரு தெளிவான பெயரைக் கொடுத்தாலும், அதன் குறிப்பு ஒரு டஜன் முறைகளுக்கு அனுப்பப்படலாம், மேலும் அந்த முறைகள் மாறியின் அசல் பெயரைப் பற்றி எதுவும் தெரியாது.
3. ஜெனரிக்ஸ்
ஜாவாவில், ஜெனரிக்ஸ் எனப்படும் குளிர்ச்சியான விஷயத்தால் இந்த எல்லா பிரச்சனைகளும் அகற்றப்படுகின்றன.
ஜாவாவில், ஜெனரிக்ஸ் என்பது வகைகளுக்கு வகை அளவுருக்களை சேர்க்கும் திறனைக் குறிக்கிறது. இதன் விளைவாக ஒரு சிக்கலான கலவை வகை உள்ளது. அத்தகைய கூட்டு வகையின் பொதுவான பார்வை இது:
ClassName<TypeParameter>
இது ஒரு பொதுவான வகுப்பு. நீங்கள் பொதுவாக வகுப்புகளைப் பயன்படுத்தும் இடங்களில் இதைப் பயன்படுத்தலாம்.
குறியீடு | விளக்கம் |
---|---|
|
மாறிகளை உருவாக்குதல் |
|
பொருட்களை உருவாக்குதல் |
|
வரிசைகளை உருவாக்குதல் |
அத்தகைய சேகரிப்பில் மாறிகள் மட்டுமே Integer
சேமிக்கப்படும்:
குறியீடு | விளக்கம் |
---|---|
|
ArrayList Integer உறுப்புகளுடன் சேகரிப்பு இது அனுமதிக்கப்படுகிறது மேலும் இதுவும் வேலை செய்யும்
ஆட்டோ பாக்ஸிங்
ஆனால் இது அனுமதிக்கப்படவில்லை: தொகுத்தல் பிழை |
ஜாவா சேகரிப்புகள் தேடலில் வகை அளவுருக்கள் மூலம் உங்கள் சொந்த வகுப்புகளை எவ்வாறு உருவாக்குவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். இப்போதைக்கு, அவற்றை எவ்வாறு பயன்படுத்துவது மற்றும் அவை எவ்வாறு செயல்படுகின்றன என்பதைப் பார்ப்போம்.
4. ஜெனரிக்ஸ் எப்படி வேலை செய்கிறது
உண்மையில், பொதுவானவை மிகவும் பழமையானவை.
கம்பைலர் பொதுவான வகைகளை சாதாரண வகைகளுடன் மாற்றுகிறது. ஆனால் ஒரு பொதுவான வகையின் முறைகள் பயன்படுத்தப்படும்போது, வகை அளவுருக்களுக்கு அளவுருக்களை அனுப்புவதற்கு ஒரு டைப்காஸ்ட் ஆபரேட்டரை கம்பைலர் சேர்க்கிறது:
குறியீடு | கம்பைலர் என்ன செய்கிறது |
---|---|
|
|
|
|
|
|
|
|
முழு எண்களின் தொகுப்பில் உள்ள எண்களை தொகுக்கும் ஒரு முறை நம்மிடம் உள்ளது என்று வைத்துக்கொள்வோம்:
குறியீடு | கம்பைலர் என்ன செய்கிறது |
---|---|
|
|
வேறு வார்த்தைகளில் கூறுவதானால், ஜெனரிக்ஸ் என்பது ஒரு வகையான தொடரியல் சர்க்கரை, ஆட்டோபாக்சிங் போன்றது, ஆனால் இன்னும் கொஞ்சம். int
ஆட்டோ பாக்ஸிங் மூலம், கம்பைலர் ஒரு ஐ மாற்றுவதற்கான முறைகளைச் சேர்க்கிறது Integer
மற்றும் அதற்கு நேர்மாறாகவும், மற்றும் ஜெனரிக்ஸுக்கு இது டைப்காஸ்ட் ஆபரேட்டர்களைச் சேர்க்கிறது.
கம்பைலர் உங்கள் பொதுவான வகுப்புகளை வகை அளவுருக்களுடன் தொகுத்த பிறகு, அவை சாதாரண வகுப்புகள் மற்றும் தட்டச்சு ஆபரேட்டர்களாக மாற்றப்படும். பொதுவான வகைகளின் மாறிகளுக்கு அனுப்பப்படும் வகை வாதங்கள் பற்றிய தகவல்கள் இழக்கப்படுகின்றன. இந்த விளைவு வகை அழித்தல் என்றும் அழைக்கப்படுகிறது .
சில நேரங்களில் பொதுவான வகுப்புகளை எழுதும் புரோகிராமர்கள் (வகை அளவுருக்கள் கொண்ட வகுப்புகள்) உண்மையில் வாதங்களாக அனுப்பப்பட்ட வகைகளைப் பற்றிய தகவல் தேவை. ஜாவா சேகரிப்புகள் தேடலில், இதை எவ்வாறு கையாள்வது மற்றும் அது எதைக் குறிக்கிறது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.
5. ஜெனரிக்ஸ் பற்றிய சில உண்மைகள்
ஜெனரிக்ஸ் பற்றிய மேலும் சில சுவாரஸ்யமான உண்மைகள் இங்கே.
வகுப்புகள் பல வகை அளவுருக்களைக் கொண்டிருக்கலாம். இது போல் தெரிகிறது:
ClassName<TypeParameter1, TypeParameter2, TypeParameter3>
உண்மையில், இது ஆச்சரியமல்ல. கம்பைலர் ஒரு வகைக்கு அனுப்புவதற்கு ஒரு ஆபரேட்டரை எங்கு வேண்டுமானாலும் சேர்க்கலாம், அது பல தட்டச்சு ஆபரேட்டர்களைச் சேர்க்கலாம்.
எடுத்துக்காட்டுகள்:
குறியீடு | குறிப்பு |
---|---|
|
முறையின் put முதல் அளவுரு a Integer , மற்றும் இரண்டாவது aString |
பொதுவான வகைகளை அளவுருக்களாகவும் பயன்படுத்தலாம் . இது போல் தெரிகிறது:
ClassName<TypeParameter<TypeParameterParameter>>
சரங்களின் பட்டியலைச் சேமிக்கும் பட்டியலை உருவாக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம். இந்த வழக்கில், இதுபோன்ற ஒன்றைப் பெறுவோம்:
// List of greetings
ArrayList<String> listHello = new ArrayList<String>();
listHello.add ("Hello");
listHello.add ("Hi");
// List of goodbyes
ArrayList<String> listBye = new ArrayList<String>();
listBye.add("Bye");
listBye.add ("Goodbye");
// List of lists
ArrayList<ArrayList<String>> lists = new ArrayList<ArrayList<String>>();
lists.add(listHello);
lists.add(listBye);
பொதுவான வகைகள் (வகை அளவுருக்கள் கொண்ட வகைகள்) வரிசை வகைகளாகவும் பயன்படுத்தப்படலாம். இது போல் தெரிகிறது:
ClassName<TypeParameter>[] array = new ClassName<TypeParameter>[size];
இங்கே மாயாஜாலமாக எதுவும் நடக்கவில்லை: கோண அடைப்புக்குறிகள் வகை பெயரைக் குறிக்கின்றன:
குறியீடு | பொதுவான அல்லாத இணை |
---|---|
|
|
|
|
|
|
GO TO FULL VERSION