2. Typy sparametryzowane (generics)

Pojęcie szablonu (template) z języka C++ zrobiło oszałamiającą karierę. W różnych innych językach są podobne konstrukcje. Również w Javie - od wersji 1.5 - mamy możliwość tworzenia czegoś na podobieństwo szablonów z C++.  Mechanizm generics z Javy różni się jednak znacząco od szablonów znanych z innych języków. Czym są generic w Javie? Jak je definiował? Jakie mają ograniczenia? I jakie użyteczne zastosowania? To tematy niniejszego wykładu.

1. Szablony - wprowadzenie

• zagwarantowane dziedziczenie klasy Object,
• implementację interfejsów,
• mechanizmy refleksji. 

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; }
}

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

     // Problem 1
     // konieczne konwersja
     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 wykonaie
     // późno, czasem w innym module
     Integer n = (Integer) po.getLast();   // ClassCastException

2. Typy sparametryzowane i ich instancje. Typy surowe. 

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; }
}

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

     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");

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();
     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 - 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).

• mniej 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.
  

• 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,
• najlepsze - zastosowanie kolekcji (list) konkretnych instancji typu sparametryzowanego.

3. Argumenty i parametry typu

• nazw klas, w tym enumeracji (enum),
• nazw interfejsów,
• nazw typów sparametryzowanych.

• 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 sprametryzowanego),
• używac 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).

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; }

  public boolean equals(Para<S,T> p) {
    return first.equals(p.first) && last.equals(p.last);
  }

  public String toString() {
    return first + " " + last;
  }
}

public class GenTest3 {

  public static void main(String[] args) {
     Para<String, Integer> p1 = new Para<String, Integer>("Ala", 3);
     Para<String, Integer> p2 = new Para<String, Integer>("Ala", 3);
     System.out.println(p1 + "\n" + p2);
     System.out.println(p1.equals(p2));
  }


}

class Para<S, T> {
  // ...
  public void swap() {
    T temp = (T) first;
    first = (S) last;
    last = temp;
  }

}

     Para<String, String> p3 = new Para<String, String>("Ala", "Kowalska");
     p3.swap();
     System.out.println(p3);

4. Wykorzystanie refleksji w szablonach

import java.lang.reflect.*;

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

  public Para() {}

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

  // konstruktor kopiujący
  public Para(Para<S,T> p) {
    // nie możemy użyć new, ale możemy zastosować refleksję
    try {
      first = (S) getInstance(p.first);  // unchecked, ale jest gwarancja
      last = (T) getInstance(p.last);    // że typy będą właściwe
    } catch (Exception exc) {
        throw new UnsupportedOperationException("Copy constructor not available",
                                                 exc.getCause());
    }
  }

  private Object getInstance(Object o) throws Exception {
     Class type = o.getClass();
     Constructor c = null;
     Object arg = null;
     try {  // czy jest konstruktor kopiujący?
       c = type.getConstructor(type);
       arg = o;
     } catch (Exception exc) {  // nie ma kopiującego
          if (type.getSuperclass() == java.lang.Number.class) { // może to boxy?
             c = type.getConstructor(java.lang.String.class);
             arg = o.toString();
          }
     }
     if (c == null) { // ani kopiujący, ani ze Stringa nie jest bezpiecznie
       // utworzyć obiekt za pomocą konstruktora bezparametrowego (newInstance)
       // pobrać od klasy Properties (PropertyDescriptor[])
       // dla wszystkich setterów wywołać odpowiednie gettery na oryginale,
       // a zwrócone wartości podać jako argumenty setterom
       // (i wołać je po kolei na kopii)
       throw new UnsupportedOperationException("Valid constructor not found in" +
                                                type);  // bo tego nie robimy
     }
     else return c.newInstance(arg);
  }

  // dodawanie par
  public Para<S, T> add(Para<S, T> p) {
    Para<S, T> wynik = new Para<S, T>(); // nie można new T(), ale można new X<T>!
    try {
      wynik.first = (S) addObjects(first, p.first); // unchecked, 
      wynik.last = (T) addObjects(last, p.last);    // ale typ jest gwarantowany
      return wynik;
    } catch(Exception exc) {
       throw new UnsupportedOperationException("Addition not allowed",
                                                exc.getCause());
    }
  }

  private Object addObjects(Object o1, Object o2) throws Exception {

    if (o1 instanceof String) return (String) o1 + o2; // konkatenacja

    if (o1 instanceof Number) { // działania na klasach opakowujących typy proste
 
      double d = ((Number) o1).doubleValue() + ((Number) o2).doubleValue();
      String s = String.valueOf(d);
      Constructor c = null;
      try {                   // wynik musi być specyficznego typu (np. Integer)
        c = o1.getClass().getConstructor(java.lang.String.class);
        return c.newInstance(s);
      } catch(Exception exc) {       // np. gdy new Integer("1.0");
          int l = s.indexOf('.');    // bierzemy tylko cyfry przed kropką
          s = s.substring(0, l);
          return c.newInstance(s);
      }
    }

    // Ani String ani Number - więc musi mieć metodę add(...)

    Class typ = o1.getClass();
    Method m = typ.getDeclaredMethod("add", typ);
    return m.invoke(o1, o2);
  }


  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 String toString() {
    return first + " " + last;
  }

}

class Value {
   int val;

   Value(int n) { val = n; }

   public Value add(Value v) {
      return new Value(val + v.val);
   }

   public String toString() {
     return "" + val;
   }

}


public class GenTest4 {

  public static void main(String[] args) {
    Para<String, Integer> p1 = new Para<String, Integer>("A", 1);
    Para<String, Integer> p2 = new Para<String, Integer>(p1);
    System.out.println(p2);
    Para<String, Integer> wynik = p1.add(p2);
    System.out.println(wynik);
    // Para <String, String> ps = new Para <String, String>("c", "d");
    // wynik = p1.add(ps); <=== kompilator wykrywa błędy
    Para<Value, Value> v1 = new Para<Value, Value>(new Value(1), new Value(2));
    Para<Value, Value> v2 = new Para<Value, Value>(new Value(3), new Value(4));
    Para<Value, Value> vv = v1.add(v2);
    System.out.println(vv);
  }

}

5. 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();
  }


}

6. Metody sparametryzowane

public class Metoda {

 public static <T extends Comparable> 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);

    Double[] da = {1.5, 231.7 };
    double dmax = max(da);

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

}

7. Parametry uniwersalne (wildcards)

List<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"

8. Użyteczność szablonów (generics) w Javie

import java.awt.*;
import javax.swing.*;
import static java.awt.Color.*;


class MComp <T extends JComponent> {

   private T comp;

   public MComp(T c) { comp = c; }

   public T getComponent() { return comp; }

   public MComp setColors(Color f, Color b) {
     comp.setForeground(f);
     comp.setBackground(b);
     return this;
   }

   public MComp setFont(String name, int ... args) {
     int style = Font.PLAIN, size = 12;
     if (args.length >= 1) size = args[0];
     if (args.length >= 2) style = args[1];
     comp.setFont(new Font(name, style, size));
     return this;
   }

   public MComp setPreferredSize(int w, int h) {
     comp.setPreferredSize(new Dimension(w, h));
     return this;
   }

}


public class Bounds0 extends JFrame {

  public Bounds0() {
    JButton b = new JButton("Generics");
    MComp<JButton> bWrap = new MComp<JButton>( b );
    bWrap.setColors(YELLOW, BLUE).setFont("Dialog",20).setPreferredSize(500,100);
    setLayout(new FlowLayout());
    add(b);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    pack();
    setVisible(true);
  }


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


}

MComp<JButton> bWrap = new MComp<JButton>( b );

public class Apply {
  public static <T, S extends Iterable<? extends T>>
  void apply(S seq, Method f, Object... args) {
    try {
      for(T t: seq)
        f.invoke(t, args);
    } catch(Exception e) {
      // Failures are programmer errors
      throw new RuntimeException(e);
    }
  }
}

class Apply {
  public static
  void apply(Iterable seq, Method f, Object... args) {
    try {
      for(Object t : seq)
        f.invoke(t, args);
    } catch(Exception e) {
      // Failures are programmer errors
      throw new RuntimeException(e);
    }
  }
}

<T, S extends Iterable<? extends T>>

// Metoda fill
// Autor: Bruce Eckel
// + moje rozszerzenia na konstruktor z argumentem

import java.util.*;
import java.lang.reflect.*;

// Dzięki implementacji tego interfejsu
// kontenery (obiekty-zestawy danych) czynić będziemy "wypełnialnymi"

interface Addable<T> { void add(T t); }

class ContainerOp {

  // Dodaje do zestawu (kontenera) cont
  // obiekty typu T (lub dowolnych jego podtypów)
  // tworzone za pomocą konstruktora z argumentem typu V
  // wywoływanego dla kolejnych argumentów  args

  public static <T, V> void fill(Addable<T> cont,
                              Class<? extends T> klasa, // aby wstawiać podtypy!
                              V ... args )
  {
    for(V arg : args)
      try {
        Constructor cons = klasa.getDeclaredConstructor(arg.getClass());
        cont.add((T)cons.newInstance(arg));
    } catch(Exception e) {
        throw new RuntimeException(e);
    }
  }

  // j.w. tylko n egzemplarzy stworzonych konstruktorem bezparemetrowym
  public static <T> void fill(Addable<T> cont,
                              Class<? extends T> klasa,
                              int n )
  {
    for (int i=0; i<n; i++)
      try {
        cont.add(klasa.newInstance());
      } catch(Exception e) {
          throw new RuntimeException(e);
      }
  }

}

// Użycie adapterów
// Autor: Bruce Eckel
// + moje drobne modyfikacje

// Kto implementuje Addable. Nie ma takiej klasy!!!!
// są jedenak klasy, w których występuje metoda add

// Aby uczynić każdą podklasę klasy X (w ktorej występuje metoda add) "addable"
// nalezy użyć kompozycji: pole oznaczające zestaw jest klasy X
// implememntujemy metodę add jako polimorficzne wywołanie na rzecz X

class AddableCollection<E> implements Addable<E> {
  private Collection<E> c;
  public AddableCollection(Collection<E> c) {
    this.c = c;
  }
  public void add(E item) { c.add(item); }
}



// Ale mogą być przypadki, gdzie jest wiele konkretnych typow-kontenerow
// dla których dodawanie jest wyrażane w różny sposób (i oczywiście nie implementują
// one interfejsu Addable)
class SomeContainer<T> implements Iterable<T> {
  private ArrayList<T> storage = new ArrayList<T>();
  public void addElement(T item) { storage.add(item); } // tutaj "addElement"
  public Iterator<T> iterator() { return storage.iterator(); }
}

// Nie warto dla każdego takiego przypadku tworzyć (wyraźnie)
// oddzielnej klasy poprzez dziedziczenie czy też kompozycję
// B. Eckel proponuje "abstract composition adapter"

abstract class AddableAdapter<S, T> implements Addable<T> {
  private S seq;
  public AddableAdapter(S sequence) { seq = sequence; }
  public S getSequence() { return seq; }
  public abstract void add(T item);
}

class Zwierz {}
class Pies extends Zwierz {}
class Kot extends Zwierz {}


class Test {

  public static void main(String[] args) {
    // Adaptacja kolekcji:
    List<String> words = new ArrayList<String>();
    ContainerOp.fill(new AddableCollection<String>(words),
                     String.class,
                     "Ala", "ma", "kota"
                    );
    for (String w : words) System.out.println(w);
    System.out.println("----------------------");
    List<Integer> ints = new ArrayList<Integer>();
    ContainerOp.fill(new AddableCollectionAdapter<Integer>(ints),
                     Integer.class,
                     "1", "2", "33"
                    );
    for (int i : ints) System.out.println(i);
    System.out.println("----------------------");


    // Użycie abstrakcyjnego adaptera
    SomeContainer<Zwierz> con = new SomeContainer<Zwierz>();


    // I tu uwaga: generics pięknie zadziałały na klasie wewn.
    // Naprawdę łatwo jest ad hoc tworzyć konkretne adaptery
    // (kompilator wie jakiego typu jest wynik getSequence()
    // i bez castingu możemy wołać metody!

    Addable<Zwierz> zwierzeta =
      new AddableAdapter<SomeContainer<Zwierz>, Zwierz>(con) {
        public void add(Zwierz item) { getSequence().addElement(item); }
      };

    ContainerOp.fill(zwierzeta, Pies.class, 7);
    ContainerOp.fill(zwierzeta, Kot.class, 3);

    for (Zwierz z : con) System.out.println(z);
  }
}

abstract class AbstractBean implements Serializable {

  protected PropertyChangeSupport chg = new PropertyChangeSupport(this);
  protected VetoableChangeSupport veto = new VetoableChangeSupport(this);

  public void addPropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }

  public void removePropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }
//... i vetoable też
// no i coś jeszcze, bo na razie nie wiele zaoszczędzamy
}

abstract class AbstractBean implements Serializable {

  protected PropertyChangeSupport chg = new PropertyChangeSupport(this);
  protected VetoableChangeSupport veto = new VetoableChangeSupport(this);

  public void addPropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }

  public void removePropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }

  // pominąłem dodawanie i usuwanie vetoableChangeListenerów

  // Opis właściwości ograniczanej

  class BoundedProperty<T>  {
    private String name;
    private T value;

    public BoundedProperty(String name) {
      this.name = name;
    }

    public T getValue() { return value; }

    public void setValue(T newValue) {
      T old = value;
      value = newValue;
      chg.firePropertyChange(name, old, value);
    }
  }

// ...
}

class TestBean extends AbstractBean {
  private BoundedProperty<Integer> count =
                                   new BoundedProperty<Integer>("count");
  int getCount()  { return count.getValue(); }
  void setCount(int n) { count.setValue(n); }
  // void setCount(String s) { count.setValue(s); } błąd w kompilacji (i o to chodziło)
}

class TestBean1 extends AbstractBean {  // Przyjemniejsza wersja
  public final BoundedProperty<Integer> count =
                                   new BoundedProperty<Integer>("count");
  public final BoundedProperty<Color> color =
                                   new BoundedProperty<Color>("color");
} 

    TestBean1 b1 = new TestBean1();
    b1.addPropertyChangeListener(this);
    b1.count.setValue(1333);
    System.out.println(b1.count.getValue());
    b1.color.setValue(RED);
    Color color = b1.color.getValue(); // mamy typy i automatyczne konwersje
    System.out.println(color);
    // b1.color.setValue(11);   <-- mamy sprawdzanie typów w kompilacji

import java.beans.*;
import java.io.*;
import java.util.*;
import java.lang.reflect.*;

abstract class AbstractBean implements Serializable {

  protected PropertyChangeSupport chg = new PropertyChangeSupport(this);
  protected VetoableChangeSupport veto = new VetoableChangeSupport(this);

  public void addPropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }

  public void removePropertyChangeListener(PropertyChangeListener pcl) {
    chg.addPropertyChangeListener(pcl);
  }

  class BoundedProperty<T>  implements PropertyChangeListener {
    private String name;
    private T value;
    private Object chgHandlerObject;
    private Method changeHandler;

    public BoundedProperty(String name) {
      this.name = name;
    }

    public T getValue() { return value; }

    public void setValue(T newValue) {
      T old = value;
      value = newValue;
      chg.firePropertyChange(name, old, value);
    }

    public void propertyChange(PropertyChangeEvent e) {
      if (!e.getPropertyName().equals(name)) return;
      if (changeHandler == null) return;
      try {
        changeHandler.invoke(chgHandlerObject);
      } catch(Exception exc) {
          exc.printStackTrace();
      }
    }

    public void setChangeHandler(Object handl, String mname) {
      try {
        Method m = handl.getClass().getDeclaredMethod(mname);
        chgHandlerObject = handl;
        changeHandler = m;
        chg.addPropertyChangeListener(this);
      } catch(Exception exc) {
          exc.printStackTrace();
          return;
      }
    }

    public void setChangeHandler(Object ohandler) {
      try {
        Method m = ohandler.getClass().getDeclaredMethod(name+"Change");
        chgHandlerObject = ohandler;
        changeHandler = m;
      } catch(Exception exc) {
          exc.printStackTrace();
          return;
      }
      chg.addPropertyChangeListener(this);
    }

    public void removeChangeHandler() {
      changeHandler = null;
      chgHandlerObject = null;
      chg.removePropertyChangeListener(this);
    }
  }


}

import java.beans.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import static java.awt.Color.*;

class TestBean extends AbstractBean {
  public final BoundedProperty<String> text =
                                   new BoundedProperty<String>("text");
  public final BoundedProperty<Color> color =
                                   new BoundedProperty<Color>("color");
}

public class ExtProps extends JFrame {

  JButton b = new JButton();
  TestBean bean = new TestBean();

  public ExtProps() {
    bean.text.setValue("Dalej");
    bean.color.setValue(BLACK);

    b.setText(bean.text.getValue());
    b.setForeground(bean.color.getValue());

    b.addActionListener( new ActionListener() {
         public void actionPerformed(ActionEvent e) {
           bean.text.setValue(bean.text.getValue() + "+");
           bean.color.setValue(bean.color.getValue().brighter());
         }
      });
    bean.color.setChangeHandler(this);
    bean.text.setChangeHandler(this);

    add(b);
    setSize(200,200);
    setVisible(true);
  }

  public void colorChange() {
    b.setForeground(bean.color.getValue().brighter().brighter());
  }

  public void textChange() {
    b.setText(bean.text.getValue());
  }



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


}

9. Podsumowanie

• jak budować klasy (i metody) sparametryzowane,
• jakie są możliwości i ograniczenia generics,
• jak stosować refleksję i generics razem, aby uzyskiwać uogólniony kod,
• co to jest "raw type",
• na czym polega "types erasure",
• co to są "wildcards",
• co to są "ograniczenia parametrów typu",
• na czym polega kowariancja, kontrawariancja i biwariancja.

10. Zadania

• wczytywania tablic z  System.in (skaner),
• sumowania liczb w tablicy i zwracania sumy (z dbałościę o właściwy typ).