Sunt multe "lucrușoare" din Java pe care chiar și cei care programează zilnic în Java nu le (mai) știu și mai ales pentru că nu le folosesc. Pentru asta există cărțile de Java, să ne mai aducă aminte de multe astfel de secrete. Recunosc, spre rușinea mea, că nu am folosit până în prezent prea mult (în mod voit) avantajele polimorfismului, cel puțin în cazul apelurilor de metode.

Și astfel ajungem la subiect. Eu nu știam sau nu mi-am pus niciodată problema că ceea ce pot face astfel cu vectori:

public class PoliArrayExample {
    public static void main(String[] args) {
        Integer[] ints = new Integer[3];
        Arrays arrs = new Arrays();
        arrs.doSomethingWithArrays(ints);
    }
}

class Arrays {
    public void doSomethingWithArrays(Object[] arr) {
        arr[0] = new String("test");
    }
}

cu colecții nu este posibil, mai exact acest lucru nu se poate face:

public class PoliArrayExample {
    public static void main(String[] args) {
        ArrayList<Integer> ints = new ArrayList<Integer>();
        Arrays arrs = new Arrays();
        arrs.doSomethingWithArrays(ints);
    }
}

class Arrays {
    public void doSomethingWithArrays(ArrayList<Object> arr) {
        arr.add("");
    }
}

Se pare că în cazul colecțiilor în momentul în care semnătura metodei public void doSomethingWithArrays(ArrayList<Object> arr) va arăta astfel, nu vom putea apela decât cu un ArrayList de tip Object, fără subclase sau superclase (nu că Object ar avea super clase, dar putem extrapola). Prin urmare, în codul anterior vom avea probleme la linia 5. Acest lucru poate fi oarecum păcălit:

public class PoliArrayExample {
    public static void main(String[] args) {
        ArrayList<Integer> ints = new ArrayList<Integer>();
        Arrays arrs = new Arrays();
        arrs.doSomethingWithArrays(ints);
    }
}

class Arrays {
    public void doSomethingWithArrays(ArrayList<? extends Object> arr) {
        arr.add("");
    }
}

spunându-i compilatorului să accepte și clase care au extins sau implementat clasa/interfața de după extends, cu condiția să nu adăugam nimic în colecția primită ca și parametru. Astfel, nu scăpăm, primind o eroare de compilare la linia 11, spunându-ne că nu există metoda add cu parametru de tip String. Putem folosi șmecheria de mai sus, atât timp cât nu adăugăm în acea colecție nimic. Și așa cum cu extends am permis accesul subclaselor, cu super putem permite accesul superclaselor:

public class PoliArrayExample {
    public static void main(String[] args) {
        ArrayList<Object> ints = new ArrayList<Object>();
        Arrays arrs = new Arrays();
        arrs.doSomethingWithArrays(ints);        
    }
}

class Arrays {
    public void doSomethingWithArrays(ArrayList<? super Integer> arr) {
        arr.add(new Integer(1));
    }
}

Și în acest caz nu vom avea nicio problemă să și adăugăm elemente în colecție, atât timp cât sunt de tipul specificat sau subclase ale tipului specificat. (mulțumesc Ducu pentru corectură!)

Toate acestea se întâmplă datorită modului în care au fost implementate genericele în Java. Cei care au făcut genericele în Java au dorit ca odată cu apariția genericelor să poată fi folosit și codul de dinainte de Java 5 și generice. Prin urmare, genericele sunt doar la nivel de compilator și la runtime un obiect de tip List<String> devine un simplu obiect List și Java nu mai are niciun control asupra ceea ce pui în lista respectivă. La vectori treaba stă altfel și un String[] chiar și la runtime tot String[] rămâne și când vom încerca să adăugăm altceva decât tipul permis vom primi o excepție (ArrayStoreException).

După cum bine se știe un Array, în Java, se poate declara în felul următor:

int[] numere[] = new int[10][10];

Parantezele pătrate se pot pune ori la tipul de date, ori la numele variabilei, ori la amândouă. De asemenea dimensiunea poate lipsi la ultimele dimensiuni ale array-ului. Deci aș fi putut scrie și așa:

int[] numere[] = new int[10][];

Există două modalități de a face declararea și inițializarea unui Array:

1. int[] numere = new int[] {1, 2, 3, 4};
   Atenție: cand se face inițializarea array-ului nu se mai trece dimensiunea!
2. int[] numere = {1, 2, 3, 4};
   Acesta este un bloc de inițializare, care poate fi folosit în locul liniei de mai sus, are același efect.

Diferența între cele două modalități este că cea de-a doua nu este o expresie și nu poate fi folosită în felul următor:

int[] numere;

numere = {1, 2, 3, 4}; //nu e ok

numere = new int[] {1, 2, 3, 4}; //e ok