Typy i metody sparametryzowane (generics)

1. Wprowadzenie

• zagwarantowane dziedziczenie klasy Object,
• implementację interfejsów,
• mechanizmy refleksji (czyli np. dynamiczne, w fazie wykonania programu, odwołania do pól i metod klas) . 

• unikania konwersji zawężających,
• tworzenia bardziej czytelnego kodu,
• wykrywania błędów w fazie kompilacji i unikania wyjątku ClassCastException.

class ParaObj {
  Object first;
  Object last;

  public ParaObj(Object f, Object l) {
    first = f;
    last = l;
  }


  public Object getFirst() { return first; }
  public Object getLast()   { return last; }

  public void setFirst(Object f) { first = f; }
  public void setLast(Object l) { last = l; }
}

• kompilator nie ma możliwości dokładnego sprawdzenia zgodności typów i błędy związane z użyciem  niewłaściwego typu pojawią się dopiero w fazie wykonania, być może w odległej przyszłości, w jakimś  innym module systemu,
• jesteśmy zmuszeni do stosowania konwersji zawężających, co czasem może być uciążliwe i zmniejsza czytelność kodu.

     ParaObj po = new ParaObj("Ala", new Integer(3));
     System.out.println(po.getFirst() + " " + po.getLast());

     // Problem 1
     // konieczne konwersje zawężające
     String name = (String) po.getFirst();
     int nr = (Integer) po.getLast();
     po.setFirst(name + " Kowalska");
     po.setLast( new Integer(nr + 1));
     System.out.println(po.getFirst() + " " + po.getLast());


     // Problem 2
     // możliwe błędy

     po.setLast("kot");
     System.out.println(po.getFirst() + " " + po.getLast());

     // Błąd może być wykryty w fazie wykonania
     // późno, czasem w innym module
     Integer n = (Integer) po.getLast();   // ClassCastException

class Para<S, T> {
  S first;
  T last;

  public Para(S f, T l) {
    first = f;
    last = l;
  }

  public S getFirst() { return first; }
  public T getLast()   { return last; }

  public void setFirst(S f) { first = f; }
  public void setLast(T l) { last = l; }
}

     Para<String, Integer> pg = new Para<String, Integer>("Ala", 3); //autoboxing
     System.out.println(pg.getFirst() + " " + pg.getLast());
     String nam = pg.getFirst();       // bez konwersji!
     int m = pg.getLast();             // bez konwersji!
     pg.setFirst(name + " Kowalska");
     pg.setLast(m+1);                  // autoboxing
     System.out.println(pg.getFirst() + " " + pg.getLast());

pg.setLast("kot");

2. Typy surowe i czyszczenie typów

import java.lang.reflect.*;

class Para<S, T> {

  static int nr;
  S first;
  T last;

  public static int getNr() { return nr; }

  public Para(S f, T l) {
    first = f;
    last = l;
    nr++;
  }

  public S getFirst() { return first; }
  public T getLast()   { return last; }

  public void setFirst(S f) { first = f; }
  public void setLast(T l) { last = l; }
}


public class GenTest2 {

  public static void main(String[] args) {
     Para<String, Integer> p1 = new Para<String, Integer>("Ala", 3);
     System.out.println(p1.getNr());
     Para<String, Integer> p2 = new Para<String, Integer>("Ala", 3);
     System.out.println(p2.getNr());
     Para<String, String> p3 = new Para<String, String>("Ala", "Kowalska");
     System.out.println(p3.getNr());

     // Co jest - tylko klasa Para
     // "Raw Type"

     Class p1Class = p1.getClass();
     System.out.println(p1Class);

     // Metodami refleksji możemy się przekonać, że
     // w definicji klasy Para typem fazy wykonania dla parametrów jest Object
     // "type erasure"!!!

     Method[] mets = p1Class.getDeclaredMethods();  // zwraca tablicę metod deklarwoanych w klasie
     for (Method m : mets) System.out.println(m);

     // Surowego typu ("Raw Type") możemy też używać
     // ale czasem wiąże się to z niuansami
     // i kompilator może nas ostrzegać o możliwych błędach


     Para p = new Para("B", new Double(3.1));
     String f = (String) p.getFirst();
     double d = (Double) p.getLast();
     System.out.println(f + " " + d);

  }
}

• jest tylko jedna klasa Para dla wszystkich instancji klasy sparametryzowanej Para<S, T>; typ wyznaczany przez tę klasę nazywa się typem surowym ("raw type"),
• z definicji klasy Para zniknęły wszystkie parametry typu i zostały zastąpione przez Object; ten mechanizm nazywa się czyszczeniem typów ("type erasure") ,
• ponieważ jest tylko jedna klasa Para - zmienne reprezentowane przez pola statyczne są wspólne dla wszystkich instancji typu sparametryzowanego; zmienna nr jest wspólna dla Para<String, Integer> i Para<String, String> - dlatego zwiększa się w sposób ciągły (1, 2, 3).

3. Restrykcje

• mniejszą liczbę klas po kompilacji,
• zgodność kodu binarnego z kodem nie używającym "generics" ("czyszczenie typów" stanowi właśnie o kompatybilności kodów używających generics z kodami nie używającymi ich).

• ograniczenia na możliwości użycia parametrów typu i wynikające stąd:
• znacznie mniejsze (niż np. w C++) możliwości prostego uogólniania klas i metod (ale funkcjonalnie uogólnianie jest dostępne na takim samym poziomie jak w C++, choćby dzięki refleksji),
• pewna trudność w definiowaniu typów sparametryzowanych - trzeba pamiętać o niuansach wprowadzanych przez wybrany sposób kompilacji,
  
• ograniczenia na możliwości parametryzacji typów.
  

• podawać je jako typy pól i zmiennych lokalnych,
• podawać je jako typy parametrów i wyników metod,
• dokonywać jawnych konwersji do typów oznaczanych przez nie (ale to będzie tylko ważne na etapie kompilacji, po to by uniknąć błędów niezgodności typów, natomiast nie uzyskamy w fazie wykonania faktycznych konwersji np. zawężających, no bo jak?),
• wywoływać na rzecz zmiennych oznaczanych typami sparametryzowanymi metody klasy Object (i ew. właściwe dla klas i interfejsów, które stanowią tzw. górne ograniczenia danego parametru typu).
  

• tworzyć obiektów typów sparametryzowanych (new T() jest niedozwolone, no bo na poziomie definicji generics nie wiadomo co to konkretnie jest T),
• używać operatora instanceOf ( z powodu j.w.),
• używać ich w statycznych kontekstach (bo statyczny kontekst jest jeden dla wszystkich różnych instancji typu sparametryzowanego),
• używać ich w literałach klasowych,
  
• wywoływać metod z konkretnych klas i interfejsów, które nie są zaznaczone jako górne ograniczenia parametru typu (w najprostszym przypadku tą górną granicą jest Object, wtedy możemy używać tylko metod klasy Object).

• używać typów sparametryzowanych przy tworzeniu tablic (podając je jako typ elementu tablicy),
• w obsłudze wyjątków (bo jest to mechanizm fazy wykonania),
• w literałach klasowych (bo oznaczają typy fazy wykonania).

• tablice typów surowych (niebezpieczne),
• tablice uniwersalnych instancji typów sparametryzowanych (uniwersalna instancja wprowadzana jest z użyciem parametru typu ?, co oznacza dowolny typ; zob. dalej); uniwersalne instancje też nie są dobrym rozwiązaniem - choć semantycznie są zbliżone do typów surowych, to składniowa różnica powoduje, że są przez kompilator traktowane inaczej niż typy surowe i w wielu przypadkach zamiast ostrzeżeń "unchecked cast" dostaniemy raczej błędy w kompilacji,
• i rozwiązanie najlepsze - zastosowanie kolekcji (list) konkretnych instancji typu sparametryzowanego.

4. Ograniczenia parametrów typu

class MinMax<T> {
   private T min;
   private  T max;

   public MinMax(T f, T l) {
     min = f;
     max = l;
   }

   public T getMin() { return min; }
   public T getMax() { return max; }
}


class GenArr<T extends Comparable<T>> {

   private  T[] arr;
   private MinMax<T> minMax;

   public GenArr(T[] a) { init(a); }

   public void init(T[] a) {
     minMax = null;
     arr = a;
   }


   public  MinMax<T> getMinMax() {
     if (minMax != null) return minMax;
     if (arr == null || arr.length == 0) return null;
     T min = arr[0];
     T max = arr[0];
     for (int i=1; i<arr.length; i++) {
       if (arr[i].compareTo(min) < 0) min = arr[i];  // dzięki T extends Comparable
       if (arr[i].compareTo(max) > 0) max = arr[i];
     }
     minMax = new MinMax<T>(min, max);
     return minMax;
   }

}

public class Bounds {

  public Bounds() {
    Integer[] arr1 = { 1, 2 , 7, -3 };
    Integer[] arr2 = { 1, 7 , 8, -10 };
    String[]  napisy = { "A", "Z", "C" };

    GenArr<Integer> ga = new GenArr<Integer>(arr1);
    MinMax<Integer> imx = ga.getMinMax();
    System.out.println(imx.getMax() + " " + imx.getMin());
    ga.init(arr2);
    imx = ga.getMinMax();
    System.out.println(imx.getMax() + " " + imx.getMin());

    GenArr<String> gas = new GenArr<String>(napisy);
    System.out.println(gas.getMinMax().getMax() + " " +
                       gas.getMinMax().getMin());
  }

  public static void main(String[] args) {
     new Bounds();
  }


}

5. Parametry uniwersalne (wildcards)

ArrayList<Integer> list1 = new ArrayList<Integer>();

• ograniczone z góry <? extends X> - oznacza "wszystkie podtypy X"
• ograniczone z dołu <? super X> - oznacza "wszystkie nadtypy X"
• nieograniczone <?> -  oznacza "wszystkie typy"

6. Metody sparametryzowane i konkludowanie typów

        specyfikatorDostępu [static] <ParametryTypu> typWyniku nazwa( lista parametrów) {
        // ...
        }

public class Metoda {

 public static <T extends Comparable<T>> T max(T[] arr) {
  T max = arr[0];
  for (int i=1; i<arr.length; i++)
    if (arr[i].compareTo(max) > 0) max = arr[i];
  return max;
 }


  public static void main(String[] args) {

    Integer[] ia = { 1, 2, 77 };
    int imax = max(ia);          // w wyniku konkluzji T staje się Integer

    Double[] da = {1.5, 231.7 };
    double dmax = max(da);       // w wyniku konkluzji T staje się Double 

    System.out.println(imax + " " + dmax);
  }

}