ஜாவாவில் அளவுருப்படுத்தப்பட்ட வகைகள்: ஜெனரிக்ஸ்

1. அனைத்து வகுப்புகளும் பரம்பரைObject

ஜாவாவில் உள்ள அனைத்து வகுப்புகளும் மறைமுகமாக Objectவகுப்பைப் பெறுகின்றன.

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

எந்த வகுப்பின் ஒரு பொருளையும் ஒரு மாறிக்கு ஒதுக்கலாம் Object. உதாரணமாக:

Object o = new Scanner(System.in);

Object o = new String();

Object o = new Integer(15);

Object o = "Hello";

இங்குதான் நல்ல செய்தி முடிகிறது. கம்பைலர் ஒரு மாறியில் சேமிக்கப்பட்ட அசல் வகைப் பொருளைக் கண்காணிக்காதுObject , எனவே நீங்கள் வகுப்பின் முறைகளைத் தவிர சேமிக்கப்பட்ட பொருளின் முறைகளை அழைக்க முடியாது .Object

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

Object o = new Scanner(System.in);
int x = o.nextInt();

Object o = new Scanner(System.in);

Scanner console = (Scanner) o;

int x = console.nextInt();

Objectஸ்கேனர் மாறிக்கு நீங்கள் சென்று ஒரு மாறியை ஒதுக்க முடியாது , Objectமாறி ஒரு பொருளின் குறிப்பை சேமித்தாலும் கூட Scanner. ஆனால் நீங்கள் ஏற்கனவே அறிந்த டைப்காஸ்ட் ஆபரேட்டரைப் பயன்படுத்தினால் இதைச் செய்யலாம் . இது அதன் பொதுவான தோற்றம்:

Type name1 = (Type) name2;

name1ஒரு மாறியின் பெயர் எங்கே Type, மற்றும் ஒரு பொருளின் குறிப்பைச் சேமிக்கும் மாறியின் name2பெயர் .ObjectType

தட்டச்சு செய்தல்

மாறியின் வகையும் பொருளின் வகையும் பொருந்தவில்லை என்றால், a ClassCastExceptionஎறியப்படும். உதாரணமாக:

Object o = new Integer(5);
String s = (String) o;

ஜாவாவில் இந்தப் பிழையைத் தவிர்க்க ஒரு வழி உள்ளது: மாறியில் சேமிக்கப்பட்ட பொருளின் வகையைச் சரிபார்த்து இதைச் செய்கிறோம் :

name instanceof Type

மாறி ஒரு பொருளா என்பதை இயக்குபவர் instanceofசரிபார்க்கிறார் .nameType

உதாரணமாக, பல்வேறு பொருள்களின் வரிசையில் ஒரு சரத்தைக் கண்டுபிடிப்போம்:

Object[] objects = {10, "Hello", 3.14};

for (int i = 0; i < objects.length; i++)
{
   if (objects[i] instanceof String)
   {
      String s = (String) objects[i];
      System.out.println(s);
   }
}

2. பொதுவானவை ஏன் தோன்றின - சேகரிப்புகள்

சேகரிப்புகளுக்கு திரும்புவோம்.

ஜாவா டெவலப்பர்கள் வகுப்பை உருவாக்கியவுடன் ArrayList, அவர்கள் அதை உலகளாவியதாக மாற்ற விரும்பினர், எனவே அது எந்த வகையான பொருளையும் சேமிக்க முடியும். Objectஎனவே அவர்கள் தனிமங்களைச் சேமிக்க s இன் வரிசையைப் பயன்படுத்தினர் .

இந்த அணுகுமுறையின் பலம் என்னவென்றால், நீங்கள் சேகரிப்பில் எந்த வகையான பொருளையும் சேர்க்கலாம்.

நிச்சயமாக, பல பலவீனங்கள் உள்ளன.

குறைபாடு 1.

ஒரு தொகுப்பிலிருந்து கூறுகளை மீட்டெடுக்கும் போது ஒரு வகை மாற்று ஆபரேட்டரை எழுதுவது எப்போதும் அவசியம்:

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 10);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

குறைபாடு 2.

ஒரு சேகரிப்பில் ஒரு குறிப்பிட்ட வகை உறுப்பு உள்ளது என்பதற்கு எந்த உத்தரவாதமும் இல்லை

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 2.5);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

தரவு எங்கும் சேகரிப்பில் வைக்கப்படலாம்:

• மற்றொரு முறையில்
• மற்றொரு திட்டத்தில்
• ஒரு கோப்பிலிருந்து
• நெட்வொர்க் மூலம்

குறைபாடு 3.

சேகரிப்பில் உள்ள தரவு தற்செயலாக மாற்றப்படலாம்.

உங்கள் தரவு நிரப்பப்பட்ட சேகரிப்பை சில முறைகளுக்கு அனுப்பலாம். வேறொரு புரோகிராமரால் எழுதப்பட்ட அந்த முறை, அதன் தரவை உங்கள் சேகரிப்பில் சேர்க்கிறது.

சேகரிப்பின் பெயர் அதில் எந்த வகையான தரவைச் சேமிக்க முடியும் என்பதைத் தெளிவாகக் குறிப்பிடவில்லை. உங்கள் மாறிக்கு ஒரு தெளிவான பெயரைக் கொடுத்தாலும், அதன் குறிப்பு ஒரு டஜன் முறைகளுக்கு அனுப்பப்படலாம், மேலும் அந்த முறைகள் மாறியின் அசல் பெயரைப் பற்றி எதுவும் தெரியாது.

3. ஜெனரிக்ஸ்

ஜாவாவில், ஜெனரிக்ஸ் எனப்படும் குளிர்ச்சியான விஷயத்தால் இந்த எல்லா பிரச்சனைகளும் அகற்றப்படுகின்றன.

ஜாவாவில், ஜெனரிக்ஸ் என்பது வகைகளுக்கு வகை அளவுருக்களை சேர்க்கும் திறனைக் குறிக்கிறது. இதன் விளைவாக ஒரு சிக்கலான கலவை வகை உள்ளது. அத்தகைய கூட்டு வகையின் பொதுவான பார்வை இது:

ClassName<TypeParameter>

இது ஒரு பொதுவான வகுப்பு. நீங்கள் பொதுவாக வகுப்புகளைப் பயன்படுத்தும் இடங்களில் இதைப் பயன்படுத்தலாம்.

ArrayList<Integer> list;

list = new ArrayList<Integer> ();

ArrayList<Integer>[] array;

அத்தகைய சேகரிப்பில் மாறிகள் மட்டுமே Integerசேமிக்கப்படும்:

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(1));
list.add(2);
list.add("Hello");

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

4. ஜெனரிக்ஸ் எப்படி வேலை செய்கிறது

உண்மையில், பொதுவானவை மிகவும் பழமையானவை.

கம்பைலர் பொதுவான வகைகளை சாதாரண வகைகளுடன் மாற்றுகிறது. ஆனால் ஒரு பொதுவான வகையின் முறைகள் பயன்படுத்தப்படும்போது, ​​வகை அளவுருக்களுக்கு அளவுருக்களை அனுப்புவதற்கு ஒரு டைப்காஸ்ட் ஆபரேட்டரை கம்பைலர் சேர்க்கிறது:

ArrayList<Integer> list = new ArrayList<Integer>();

ArrayList list = new ArrayList();

list.add(1);

list.add( (Integer) 1 );

int x = list.get(0);

int x = (Integer) list.get(0);

list.set(0, 10);

list.set(0, (Integer) 10);

முழு எண்களின் தொகுப்பில் உள்ள எண்களை தொகுக்கும் ஒரு முறை நம்மிடம் உள்ளது என்று வைத்துக்கொள்வோம்:

public int sum(ArrayList<Integer> numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + numbers.get(i);

   return result;
}

public int sum(ArrayList numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + (Integer) numbers.get(i);

   return result;
}

வேறு வார்த்தைகளில் கூறுவதானால், ஜெனரிக்ஸ் என்பது ஒரு வகையான தொடரியல் சர்க்கரை, ஆட்டோபாக்சிங் போன்றது, ஆனால் இன்னும் கொஞ்சம். intஆட்டோ பாக்ஸிங் மூலம், கம்பைலர் ஒரு ஐ மாற்றுவதற்கான முறைகளைச் சேர்க்கிறது Integerமற்றும் அதற்கு நேர்மாறாகவும், மற்றும் ஜெனரிக்ஸுக்கு இது டைப்காஸ்ட் ஆபரேட்டர்களைச் சேர்க்கிறது.

கம்பைலர் உங்கள் பொதுவான வகுப்புகளை வகை அளவுருக்களுடன் தொகுத்த பிறகு, அவை சாதாரண வகுப்புகள் மற்றும் தட்டச்சு ஆபரேட்டர்களாக மாற்றப்படும். பொதுவான வகைகளின் மாறிகளுக்கு அனுப்பப்படும் வகை வாதங்கள் பற்றிய தகவல்கள் இழக்கப்படுகின்றன. இந்த விளைவு வகை அழித்தல் என்றும் அழைக்கப்படுகிறது .

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

5. ஜெனரிக்ஸ் பற்றிய சில உண்மைகள்

ஜெனரிக்ஸ் பற்றிய மேலும் சில சுவாரஸ்யமான உண்மைகள் இங்கே.

வகுப்புகள் பல வகை அளவுருக்களைக் கொண்டிருக்கலாம். இது போல் தெரிகிறது:

ClassName<TypeParameter1, TypeParameter2, TypeParameter3>

உண்மையில், இது ஆச்சரியமல்ல. கம்பைலர் ஒரு வகைக்கு அனுப்புவதற்கு ஒரு ஆபரேட்டரை எங்கு வேண்டுமானாலும் சேர்க்கலாம், அது பல தட்டச்சு ஆபரேட்டர்களைச் சேர்க்கலாம்.

எடுத்துக்காட்டுகள்:

HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(7, "Hello");
map.put(-15, "Hello");

பொதுவான வகைகளை அளவுருக்களாகவும் பயன்படுத்தலாம் . இது போல் தெரிகிறது:

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];

இங்கே மாயாஜாலமாக எதுவும் நடக்கவில்லை: கோண அடைப்புக்குறிகள் வகை பெயரைக் குறிக்கின்றன:

ArrayList<String>[] list = new ArrayList<String>[10];

StringArrayList[] list = new StringArrayList[10];

ArrayList<Integer>[] list = new ArrayList<Integer>[10];

IntegerArrayList[] list = new IntegerArrayList[10];

ArrayList<Scanner>[] list = new ArrayList<Scanner>[10];

ScannerArrayList[] list = new ScannerArrayList[10];