Generice in Java Introducere Incepand cu JDK 1.5 s-au adaugat genericele in Java asemanator cu template-urile din C++.

La baza genericelor e polimorfismul parametric gasit in limbajele functionale ML si Haskell. Genericele si colectiile sunt optimizate pentru noile facilitate introduce in Java ca: -auto-boxing, un-boxing -instructiunea for-each, ca noua instructiune recursive -functii cu un numar variabil de parametrii, varargs. Vom analiza aspectele legate de : -Liste de Integers sub aspectul generic, negeneric si cu tablouri de tip int primitive -Liste de String-uri sub aspectul generic si negeneric -Alte elemente legate de generice Exemplu:
import java.util.*; public class Gen1 { public static void main(String[] args) { List <Integer> ints =Arrays.asList(1,2,3); //asList() metoda static de tip varargs int s=0; for (int n:ints){s+=n;} assert s==6; System.out.println("\n Generice List 1- Integer"); //L2= no generics List ints1 = Arrays.asList(new Integer[]{new Integer(1), new Integer(2), new Integer (3)}); int s1=0; for(Iterator it=ints1.iterator(); it.hasNext();){ int n1= ((Integer)it.next()).intValue(); s1+=n1; } assert s1==6; System.out.println("\n Generice List 2 - no generics");

//L3 - arrays int [] ints3 = new int[] {1,2,3}; int s3=0; for (int i=0;i<ints3.length;i++){s3+=ints3[i];} assert s3==6; System.out.println("\n Generice List 3 - arrays"); //Lw List <String> words = new ArrayList <String> (); words.add("Hello"); words.add(" world"); String sw = words.get(0) + words.get(1); assert sw.equals("Hello world"); System.out.println("\n Generic ListW - String"); //Lw-no generics List words1 = new ArrayList(); words1.add("Hello"); words1.add(" world"); String sw1 = ((String)words.get(0)) + ((String)words.get(1)); assert sw1.equals("Hello world"); System.out.println("\n Generic ListW1 - no generics"); //Generice, for-each, etc. List <Integer> intsL = Gen1.toList(new Integer[] {1,2,3}); List <String> wordsL = Gen1.toList(new String[]{"Hello", " world"}); //vars List <Integer> intsV = Gen1.toListV(1,2,3); List <String> wordsV = Gen1.toListV("Hello", " world"); // param List <Integer> intsW = new ArrayList <Integer>(); Gen1.addAll(intsW, 1, 2);//invocare argumente Gen1.addAll(intsW, new Integer[]{3,4});//dat tablou assert intsW.toString().equals("{1,2,3,4]"); System.out.println("\n Generic intsW - "); }//main public static <T> List <T> toList (T[] arr){ List <T> list = new ArrayList <T> (); for (T elt :arr) list.add(elt); return list; }//toList public static <T> List <T> toListV (T... arr){ List <T> list = new ArrayList <T> (); for (T elt :arr) list.add(elt); return list; }//toListV //append cu parametrii suplimentari fata de varargs public static <T> void addAll(List <T> list, T...arr){

for(T elt:arr) list.add(elt); }//addAll }//class

Folosind generice boxing/unboxing, for-each si varargs, in Java se ajunge ca utilizand colectii mecanismul de programare sa fie mai simplu chiar de a folosi tablouri. Cu ajutorul genericelor intre paranteze unghiulare clasele si interfetele pot folosi mai multe tipuri de date intr-un mecanism unificat. A se vedea utilizarea genericelor la lucrul cu String-uri din exemplu. Genericele in Java sunt implementate printr-un mecanism de Erasure Stergere pentru ca List <Integer> , List <String>, etc. vor fi reprezentate la executie prin acelas tip si anume, List. Mecanismul de cast-ing este realizat in mod implicit la generice. El e numit, cast-iron guarantee, si nu da greseli. Implementarea genericelor prin Erasure aduce beneficii ca: -lucrurile raman simple, ele neaadugand in final ceva nou -lucrurile raman mici, fiind o singura implementare pentru List, nu o noua versiune pentru fiecare tip generic -permite evolutia aceleiasi biblioteci putand fi folosita generic sau nu. Practic byte-codul obtinut cu generice si fara generice este acelas. Constructiile: -new Srting[size], adica tablou de String-uri, memoreaza in tablou o indicatie ca am String-uri -new ArrayList <String>, aloca o lista, dar nu memoreaza in lista o indicatie despre natura elementelor. In Java deci genericele sunt prin Erasure pe cand in C++ ele sunt prin Expansion. Template-urile din C++ fac ca la fiecare instantiere cu un nou tip, acesta va fi compilat separat si sa apara atatea versiuni de cod cate tipuri sunt, lucru ce poate duce la probleme de gen Coad bloat. Varianta C++ e mai eficienta mai ales la gestiunea unui numar mare de date, permitand optimizari.

In C++, se pot instantia template-uri cu un numar constant, aparand asa numitul Macroprocessor on stereoids ce poate realiza calcule complexe arbitrare la compilare. Genericele in Java sunt deliberat restrictive pentru a le pastra simple si usor de inteles. Boxing-ul si unboxingul permite conversia dintr-un tip primitiv la referinta asociata corespunzatoare, si invers. In Java cu generice daca o expresie E de tip int apare unde ar trebui Integer, prin boxing se realizeaza automat Integer(E). De asemenea daca o expresie E de tip Integer apare unde ar trebui sa fie un int, unboxing face automat conversia E.intValue(), adica in int. Instructiunea for-each se poate aplica la ori ce obiect care implementeaza o interfata Iterable <E> din java.lang care se refera la Iterator<E> din java.util unde sunt metodele: iterator(), hasNext(), next(). Ori ce numar de argumente poate precede ultimul argument de tip varargs, care se foloseste atunci cand ultimul argument este de tip tablou. Apelul unei metode ce are varargs se poate face dand o lista de argumente, sau explicit un tablou. La metodele generice tipul parametrilor poate fi dedus, inferred, dar poate fi si specificat explicit.

List <Integer> intsL = Gen1.toList(); List <Object> objs = Gen1 <objects> toList (1, two); Parametrii expliciti, uzual, nu sunt folositi, dar uneori ajuta la o mai buna intelegere. Regula de apel a unei metode generice: - daca unul sau mai multi parametrii corespund tipurilor de parametrii si toti au acelas tip, atunci tipul este dedus implicit, inferred. Daca sunt argumente ce nu corespund tipului, sau argumente ce apartin unui subtip diferit, atunci parametrii se dau explicit. La apelul unei metode generice parametrul apare intre < > in partea stanga la fel ca la declararea metodei.