జావాలో జెనరిక్స్

హాయ్! మేము జావా జెనరిక్స్ గురించి మాట్లాడబోతున్నాము. మీరు చాలా నేర్చుకుంటారు అని నేను తప్పక చెప్పాలి! ఈ పాఠం మాత్రమే కాకుండా, తదుపరి కొన్ని పాఠాలు కూడా జనరిక్స్‌కు అంకితం చేయబడతాయి. కాబట్టి, మీకు జెనరిక్స్ పట్ల ఆసక్తి ఉన్నట్లయితే, ఈ రోజు మీకు అదృష్ట దినం: మీరు జెనరిక్స్ లక్షణాల గురించి చాలా నేర్చుకుంటారు. మరియు లేకపోతే, మీరే రాజీనామా చేసి విశ్రాంతి తీసుకోండి! :) ఇది చాలా ముఖ్యమైన అంశం, మరియు మీరు దీన్ని తెలుసుకోవాలి. సరళమైన వాటితో ప్రారంభిద్దాం: "ఏమి" మరియు "ఎందుకు".

జావా జెనరిక్స్ అంటే ఏమిటి?

జెనరిక్స్ అంటే పరామితి ఉన్న రకాలు. సాధారణ రకాన్ని సృష్టించేటప్పుడు, మీరు ఒక రకాన్ని మాత్రమే కాకుండా, అది పని చేసే డేటా రకాన్ని కూడా పేర్కొనండి. చాలా స్పష్టమైన ఉదాహరణ ఇప్పటికే మీ దృష్టికి వచ్చిందని నేను ఊహిస్తున్నాను: అర్రేలిస్ట్! మేము సాధారణంగా ప్రోగ్రామ్‌లో ఒకదాన్ని ఈ విధంగా సృష్టిస్తాము:

import java.util.ArrayList;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<String> myList1 = new ArrayList<>();
       myList1.add("Test String 1");
       myList1.add("Test String 2");
   }
}

మీరు ఊహించినట్లుగా, ఈ జాబితా యొక్క లక్షణం ఏమిటంటే, మేము దానిలో అన్నింటినీ నింపలేము: ఇది స్ట్రింగ్ ఆబ్జెక్ట్‌లతో ప్రత్యేకంగా పని చేస్తుంది. ఇప్పుడు జావా చరిత్రలోకి కొంచెం డైగ్రెషన్ తీసుకొని "ఎందుకు?" అనే ప్రశ్నకు సమాధానం ఇవ్వడానికి ప్రయత్నిద్దాం. దీన్ని చేయడానికి, మేము అర్రేలిస్ట్ క్లాస్ యొక్క మా స్వంత సరళీకృత సంస్కరణను వ్రాస్తాము. అంతర్గత శ్రేణికి డేటాను జోడించడం మరియు తిరిగి పొందడం ఎలాగో మా జాబితాకు మాత్రమే తెలుసు:

public class MyListClass {

   private Object[] data;
   private int count;

   public MyListClass() {
       this.data = new Object[10];
       this.count = 0;
   }

   public void add(Object o) {
       this.data[count] = o;
       count++;
   }

   public Object[] getData() {
       return data;
   }
}

మన జాబితా పూర్ణాంక లను మాత్రమే నిల్వ చేయాలని అనుకుందాం . మేము సాధారణ రకాన్ని ఉపయోగించడం లేదు. మేము add() పద్ధతిలో స్పష్టమైన "instanceof Integer " చెక్‌ని చేర్చకూడదనుకుంటున్నాము . మేము అలా చేస్తే, మా తరగతి మొత్తం పూర్ణాంకానికి మాత్రమే సరిపోతుంది మరియు మేము ప్రపంచంలోని ప్రతి ఇతర డేటా రకానికి ఒకే విధమైన తరగతిని వ్రాయవలసి ఉంటుంది! మేము మా ప్రోగ్రామర్‌లపై ఆధారపడతాము మరియు వారు మనకు అక్కరలేని వాటిని జోడించరని నిర్ధారించుకోవడానికి కోడ్‌లో వ్యాఖ్యానించండి:

// Use this class ONLY with the Integer data type
public void add(Object o) {
   this.data[count] = o;
   count++;
}

ప్రోగ్రామర్‌లలో ఒకరు ఈ వ్యాఖ్యను కోల్పోయారు మరియు అనుకోకుండా అనేక స్ట్రింగ్‌లను సంఖ్యల జాబితాలో ఉంచి, ఆపై వాటి మొత్తాన్ని లెక్కించారు:

public class Main {

   public static void main(String[] args) {

       MyListClass list = new MyListClass();
       list.add(100);
       list.add(200);
       list.add("Lolkek");
       list.add("Shalala");

       Integer sum1 = (Integer) list.getData()[0] + (Integer) list.getData()[1];
       System.out.println(sum1);

       Integer sum2 = (Integer) list.getData()[2] + (Integer) list.getData()[3];
       System.out.println(sum2);
   }
}

కన్సోల్ అవుట్‌పుట్:

300 
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer 
      at Main.main (Main.java:14)

ఈ పరిస్థితి యొక్క చెత్త భాగం ఏమిటి? ఖచ్చితంగా ప్రోగ్రామర్ యొక్క అజాగ్రత్త కాదు. చెత్త భాగం ఏమిటంటే, తప్పు కోడ్ మా ప్రోగ్రామ్‌లో ఒక ముఖ్యమైన ప్రదేశంలో ముగిసింది మరియు విజయవంతంగా కంపైల్ చేయబడింది. ఇప్పుడు మనం బగ్‌ని ఎదుర్కొంటాము కోడ్ వ్రాసేటప్పుడు కాదు, కానీ పరీక్ష సమయంలో మాత్రమే (మరియు ఇది ఉత్తమ సందర్భం!). అభివృద్ధి యొక్క తరువాతి దశలలో దోషాలను పరిష్కరించడానికి చాలా ఎక్కువ ఖర్చు అవుతుంది - డబ్బు మరియు సమయం రెండింటిలోనూ. ఇక్కడే జెనరిక్‌లు మనకు ప్రయోజనం చేకూరుస్తాయి: జెనరిక్ క్లాస్ దురదృష్టకర ప్రోగ్రామర్‌ని వెంటనే లోపాన్ని గుర్తించేలా చేస్తుంది. కార్యక్రమం కేవలం కంపైల్ కాదు!

import java.util.ArrayList;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<Integer> myList1 = new ArrayList<>();
      
       myList1.add(100);
       myList1.add(100);
       myList1.add ("Lolkek"); // Error!
       myList1.add("Shalala"); // Error!
   }
}

ప్రోగ్రామర్ వెంటనే తన తప్పును తెలుసుకుని, తక్షణమే మెరుగుపడతాడు. మార్గం ద్వారా, ఈ విధమైన లోపాన్ని చూడటానికి మేము మా స్వంత జాబితా తరగతిని సృష్టించాల్సిన అవసరం లేదు. యాంగిల్ బ్రాకెట్‌లను తీసివేసి, సాధారణ అర్రేలిస్ట్ నుండి ( <Integer> ) టైప్ చేయండి!

import java.util.ArrayList;
import java.util.List;

public class Main {

   public static void main(String[] args) {

      List list = new ArrayList();

      list.add(100);
      list.add(200);
      list.add("Lolkek");
      list.add("Shalala");

       System.out.println((Integer) list.get(0) + (Integer) list.get(1));
       System.out.println((Integer) list.get(2) + (Integer) list.get(3));
   }
}

కన్సోల్ అవుట్‌పుట్:

300 
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer 
     at Main.main(Main.java:16)

మరో మాటలో చెప్పాలంటే, జావా యొక్క "స్థానిక" మెకానిజమ్‌లను ఉపయోగించి కూడా, మనం ఈ విధమైన పొరపాటు చేయవచ్చు మరియు అసురక్షిత సేకరణను సృష్టించవచ్చు. అయినప్పటికీ, మేము ఈ కోడ్‌ను IDEలో అతికించినట్లయితే, మనకు హెచ్చరిక వస్తుంది: "జావా.util.List యొక్క ముడి రకం సభ్యునిగా జోడించడానికి(E) ఎంపిక చేయని కాల్" ఒక అంశాన్ని జోడించేటప్పుడు ఏదో తప్పు జరగవచ్చని మాకు చెప్పబడింది. సాధారణ రకం లేని సేకరణకు. కానీ "ముడి రకం" అనే పదానికి అర్థం ఏమిటి? ముడి రకం అనేది సాధారణ తరగతి, దీని రకం తీసివేయబడింది. మరో మాటలో చెప్పాలంటే, జాబితా myList1 ఒక ముడి రకం . ముడి రకానికి వ్యతిరేకం ఒక సాధారణ రకం — పారామీటర్ చేయబడిన రకం(లు) యొక్క సూచనతో కూడిన సాధారణ తరగతి . ఉదాహరణకు, List<String> myList1. ముడి రకాల వినియోగాన్ని భాష ఎందుకు అనుమతిస్తుంది అని మీరు అడగవచ్చు ? కారణం సులభం. జావా యొక్క సృష్టికర్తలు అనుకూలత సమస్యలను సృష్టించకుండా ఉండటానికి భాషలో ముడి రకాలకు మద్దతును వదిలివేశారు. జావా 5.0 విడుదలయ్యే సమయానికి (ఈ సంస్కరణలో జెనరిక్స్ మొదట కనిపించింది), ముడి రకాలను ఉపయోగించి ఇప్పటికే చాలా కోడ్‌లు వ్రాయబడ్డాయి . ఫలితంగా, ఈ యంత్రాంగానికి నేటికీ మద్దతు ఉంది. మేము పాఠాలలో జాషువా బ్లాచ్ యొక్క క్లాసిక్ పుస్తకం "ఎఫెక్టివ్ జావా" గురించి పదేపదే ప్రస్తావించాము. భాష యొక్క సృష్టికర్తలలో ఒకరిగా, అతను తన పుస్తకంలో ముడి రకాలు మరియు సాధారణ రకాలను దాటవేయలేదు.పుస్తకంలోని 23వ అధ్యాయం చాలా అనర్గళమైన శీర్షికను కలిగి ఉంది: "కొత్త కోడ్‌లో ముడి రకాలను ఉపయోగించవద్దు" ఇది మీరు గుర్తుంచుకోవాల్సిన అవసరం ఉంది. జెనరిక్ తరగతులను ఉపయోగిస్తున్నప్పుడు, జెనరిక్ రకాన్ని ఎప్పుడూ ముడి రకంగా మార్చవద్దు .

సాధారణ పద్ధతులు

జావా జెనరిక్ పద్ధతులు అని పిలవబడే వాటిని సృష్టించడం ద్వారా వ్యక్తిగత పద్ధతులను పారామీటర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. అలాంటి పద్ధతులు ఎలా ఉపయోగపడతాయి? అన్నింటికంటే మించి, వివిధ రకాల మెథడ్ పారామితులతో పని చేయడానికి మిమ్మల్ని అనుమతించడంలో అవి సహాయపడతాయి. ఒకే తర్కాన్ని వివిధ రకాలకు సురక్షితంగా అన్వయించగలిగితే, సాధారణ పద్ధతి ఒక గొప్ప పరిష్కారం. దీన్ని చాలా సులభమైన ఉదాహరణగా పరిగణించండి: మన దగ్గర myList1 అని పిలువబడే కొన్ని జాబితా ఉందని అనుకుందాం . మేము జాబితా నుండి అన్ని విలువలను తీసివేసి, అన్ని ఖాళీ స్థలాలను కొత్త విలువలతో నింపాలనుకుంటున్నాము. సాధారణ పద్ధతితో మా తరగతి ఎలా ఉంటుందో ఇక్కడ ఉంది:

public class TestClass {

   public static <T> void fill(List<T> list, T val) {
       for (int i = 0; i < list.size(); i++)
           list.set(i, val);
   }

   public static void main(String[] args) {

       List<String> strings = new ArrayList<>();
       strings.add("Old String 1");
       strings.add("Old String 2");
       strings.add("Old String 3");

       fill(strings, "New String");

       System.out.println(strings);

       List<Integer> numbers = new ArrayList<>();
       numbers.add(1);
       numbers.add(2);
       numbers.add(3);

       fill(numbers, 888);
       System.out.println(numbers);
   }
}

వాక్యనిర్మాణంపై శ్రద్ధ వహించండి. ఇది కొంచెం అసాధారణంగా కనిపిస్తుంది:

public static <T> void fill(List<T> list, T val)

రిటర్న్ రకానికి ముందు మేము <T> అని వ్రాస్తాము. మేము సాధారణ పద్ధతితో వ్యవహరిస్తున్నామని ఇది సూచిస్తుంది. ఈ సందర్భంలో, పద్ధతి 2 పారామితులను ఇన్‌పుట్‌గా అంగీకరిస్తుంది: T ఆబ్జెక్ట్‌ల జాబితా మరియు మరొక ప్రత్యేక T వస్తువు. <T>ని ఉపయోగించడం ద్వారా, మేము పద్ధతి యొక్క పారామీటర్ రకాలను పారామీటర్ చేస్తాము: మేము స్ట్రింగ్‌లు మరియు పూర్ణాంకాల జాబితాలో ఉత్తీర్ణత సాధించలేము. స్ట్రింగ్‌లు మరియు స్ట్రింగ్‌ల జాబితా, పూర్ణాంకాల జాబితా మరియు పూర్ణాంకం, మన స్వంత క్యాట్ వస్తువులు మరియు మరొక పిల్లి వస్తువు యొక్క జాబితా — మనం చేయాల్సింది ఇదే. వివిధ రకాల డేటాతో పని చేయడానికి పూరకం() పద్ధతిని సులభంగా ఎలా ఉపయోగించవచ్చో ప్రధాన () పద్ధతి వివరిస్తుంది . ముందుగా, మేము స్ట్రింగ్‌ల జాబితా మరియు స్ట్రింగ్‌ని ఇన్‌పుట్‌గా, ఆపై పూర్ణాంకాల జాబితాతో మరియు పూర్ణాంకాలతో పద్ధతిని ఉపయోగిస్తాము. కన్సోల్ అవుట్‌పుట్:

[New String, New String, New String] [888, 888, 888]

మనకు సాధారణ పద్ధతులు లేకపోయినా మరియు 30 విభిన్న తరగతులకు పూరక() పద్ధతి యొక్క లాజిక్ అవసరమా అని ఆలోచించండి. మేము వివిధ డేటా రకాల కోసం ఒకే పద్ధతిని 30 సార్లు వ్రాయవలసి ఉంటుంది! కానీ సాధారణ పద్ధతులకు ధన్యవాదాలు, మేము మా కోడ్‌ను మళ్లీ ఉపయోగించుకోవచ్చు! :)

సాధారణ తరగతులు

మీరు ప్రామాణిక జావా లైబ్రరీలలో అందించిన సాధారణ తరగతులకు మాత్రమే పరిమితం కాలేదు — మీరు మీ స్వంతంగా సృష్టించుకోవచ్చు! ఇక్కడ ఒక సాధారణ ఉదాహరణ:

public class Box<T> {

   private T t;

   public void set(T t) {
       this.t = t;
   }

   public T get() {
       return t;
   }

   public static void main(String[] args) {

       Box<String> stringBox = new Box<>();

       stringBox.set("Old String");
       System.out.println(stringBox.get());
       stringBox.set("New String");

       System.out.println(stringBox.get());
      
       stringBox.set(12345); // Compilation error!
   }
}

మా బాక్స్<T> తరగతి సాధారణ తరగతి. సృష్టి సమయంలో మేము డేటా రకాన్ని ( <T> ) కేటాయించిన తర్వాత, మేము ఇకపై ఇతర రకాల వస్తువులను అందులో ఉంచలేము. ఇది ఉదాహరణలో చూడవచ్చు. మా వస్తువును సృష్టించేటప్పుడు, ఇది స్ట్రింగ్‌లతో పని చేస్తుందని మేము సూచించాము:

Box<String> stringBox = new Box<>();

మరియు కోడ్ యొక్క చివరి పంక్తిలో, బాక్స్ లోపల 12345 సంఖ్యను ఉంచడానికి ప్రయత్నించినప్పుడు, మనకు సంకలన లోపం వస్తుంది! ఇది చాలా సులభం! మేము మా స్వంత సాధారణ తరగతిని సృష్టించాము! :) దాంతో ఈరోజు పాఠం ముగిసిపోతుంది. కానీ మేము జెనరిక్స్‌కు వీడ్కోలు చెప్పడం లేదు! తదుపరి పాఠాలలో, మేము మరింత అధునాతన ఫీచర్‌ల గురించి మాట్లాడుతాము, కాబట్టి మీరు దూరంగా ఉండకండి! ) మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మీరు మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడాలని మేము సూచిస్తున్నాము మీ అధ్యయనాలలో ఉత్తమ విజయం! :)