జావాలో పారామీటర్ చేయబడిన రకాలు: జనరిక్స్

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, మీరు కేవలం వెళ్లి స్కానర్ వేరియబుల్‌కు వేరియబుల్‌ను కేటాయించలేరు . ObjectScannerకానీ మీరు టైప్‌కాస్ట్ ఆపరేటర్‌ని ఉపయోగిస్తే మీరు దీన్ని చేయవచ్చు , ఇది మీకు ఇప్పటికే తెలుసు. ఇది దాని సాధారణ రూపం:

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ఆటోబాక్సింగ్‌తో, కంపైలర్ aని ఒకకి మార్చడానికి పద్ధతులను జోడిస్తుంది 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];