Generics అంటే ఏమిటి మరియు ఎందుకు వాటిని ఉపయోగించాలి?

Question

Accepted Answer

**Generics** తరగతులు, ఇంటర్‌ఫేసులు మరియు పద్ధతులను రాయడానికి మిమ్మల్ని అనుమతిస్తాయి, ఇవి కాలర్ ద్వారా నిర్దేశించిన **టైప్ పరామితి**తో పని చేస్తాయి — **కంపైల్-టైమ్ టైప్ సేఫ్టీ** అందించి మరియు కాస్టింగ్ యొక్క అవసరాన్ని తొలగిస్తాయి. అవి Collections Framework మరియు పునర్ఉపయోగపడే లైబ్రరీలను శక్తివంతం చేస్తాయి. ## Generics పరిష్కరించే సమస్య ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` Generics రన్‌టైమ్ (`ClassCastException`) నుండి **కంపైల్ టైమ్**‌కు టైప్ ఎర్రర్‌లను తరలించి, మానవీయ కాస్టింగ్ అవసరాన్ని తీసివేస్తాయి — కోడ్‌ను సురక్షితం మరియు స్వచ్ఛతరం చేస్తాయి. ## సాధారణ తరగతులు మరియు పద్ధతులు ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## సీమాబద్ధ టైప్ పరామితులు ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` టైప్ పరామితిని సీమాబద్ధం చేస్తుంది, ఆ టైప్ యొక్క సభ్యులను సురక్షితంగా ఉపయోగించడానికి మిమ్మల్ని సక్షమం చేస్తుంది. ## వైల్డ్‌కార్డ్‌లు ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` వైల్డ్‌కార్డ్‌లు పద్ధతి పరామితులకు వశ్యత జోడిస్తాయి, అవి వర్గాల శ్రేణులను అంగీకరించాలి. ## టైప్ erasure (Java హెచ్చరిక) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java **టైప్ erasure** ద్వారా generics ను అమలు చేస్తుంది — టైప్ పరామితులు కంపైల్ సమయంలో ఉన్నాయి కానీ రన్‌టైమ్‌లో తీసివేయబడతాయి, ఇది కొన్ని పరిమితులను కలిగి ఉంది. ## ఇది ఎందుకు ముఖ్యమైనది Generics ఆధునిక Java కోసం అవసరం — అవి కంపైల్-టైమ్ టైప్ సేఫ్టీ (టైప్ ఎర్రర్‌లను రన్‌టైమ్ `ClassCastException`‌ల వలె ఆర్లీ క్యాచ్ చేస్తాయి), వర్బోస్ మరియు ఎర్రర్-ప్రోన్ కాస్టింగ్‌లను తొలగిస్తాయి, మరియు పునర్ఉపయోగపడే, టైప్-ఫ్లెక్సిబుల్ కోడ్‌ను ప్రారంభిస్తాయి. వాటి మొత్తం Collections Framework (`List`, `Map`) మరియు అసంఖ్యాక లైబ్రరీల ఆధారం. సాధారణ తరగతులు/పద్ధతులు, సీమాబద్ధ పరామితులు, వైల్డ్‌కార్డ్‌లు (PECS), మరియు టైప్-erasure హెచ్చరికను అర్థం చేసుకోవడం సాధారణ API‌లను సరిగ్గా ఉపయోగించుకోవటానికి మరియు మీ స్వంత పునర్ఉపయోగపడే, టైప్-సేఫ్ abstractions ను డిజైన్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది — బలమైన, నిర్వహణీయ Java రాయడానికి కోర్ నైపుణ్యం.