3. Dynamiczna Java i programowanie komponentowe (JavaBeans)

Java jest językiem interpretowanym. Kompilator tworzy kod bajtowy, ten zaś podlega interpretacji przez wirtualną maszynę Javy.
Daje to podstawy do dynamicznego, w fazie wykonania, kształtowaniu mechanizmów działania programu. Osiągamy to dzięki tzw. refleksji.

Refleksja jest też wewnętrznym mechanizmem technologii JavaBeans
Termin JavaBeans wiąże się  z koncepcją budowania programów z gotowych, łatwo dostosowywanych do konkretnych potrzeb, komponentów programowych. Idea to niezwykle kusząca, ale jednocześnie – z niewiadomych powodów – owiana nimbem "wyższego wtajemniczenia".  W bardzo krótkim wprowadzeniu do JavaBeans zobaczymy, że nie ma tu nic tajemniczego ani trudnego. Myślę, że będzieono całkiem wystarczające, by zrozumieć podstawowe koncepcje JavaBeans, a dodatkowe szczegóły "techniczne" łatwo można uzupelnić na podstawie dokumentacji SDK Javy..

3.1. Dynamiczne ładowanie klas.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;

class Main extends JFrame {

static void exit(String s) { System.out.println(s); System.exit(1); }

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

Main(String actionClassName) {
 Class actionClass = null;
 Action act = null;
 try {
       actionClass = Class.forName(actionClassName);
       act = (Action) actionClass.newInstance();
  } catch (Exception exc) {exit("Obiekt klasy akcji nie może być utworzony");}

 JButton b = new JButton();
 b.setAction(act);
 getContentPane().add(b);
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 pack();
 show();
 }
}

import javax.swing.*;
import java.awt.event.*;

public class DialogAction extends AbstractAction {

  final static String ACTION_NAME = "Show msg";

   public DialogAction() {
     super(ACTION_NAME);
   }

   public void actionPerformed(ActionEvent e) {
     JOptionPane.showMessageDialog(null, ACTION_NAME);
   }

}

import javax.swing.*;
import java.awt.event.*;

public class PrintAction extends AbstractAction {

  final static String ACTION_NAME = "Print";

   public PrintAction() {
     super(ACTION_NAME);
   }

   public void actionPerformed(ActionEvent e) {
     System.out.println("Wykonan akcja: " + ACTION_NAME);
   }

}

3.2. Refleksja

• stwierdzenie jakie i z jakimi argumentami metody występują w danej klasie (np. podawanej dynamicznie w trakcie wykonania programu)
• dynamiczne wywoływanie metod (specyfikowanych w trakcie wykonania programu) na rzecz jakiego obiektu (też dynamicznie ustalanego),
• dynamiczne uzyskiwanie i modyfikacje wartości pól obiektu.

 Klasy pakietu java.lang.reflect

 
Użyteczne metody klasy java.lang.Class

• metody bez "Declared" zwracają składowe tylko publiczne, ale jednocześnie również dziedziczone,

• metody z "Declared" zwracają wszystkie składowe (również prywatne i zabezpieczone), ale bez dziedziczonych

3.3.  Przykład wykorzystania refleksji

class ActionsSet {
  public void Action1() { System.out.println("Action1"); }
  public void Action2() { System.out.println("Action2"); }
  public void Action3() { System.out.println("Action3"); }
  public void Action4() { System.out.println("Action4"); }
  public void Action5() { System.out.println("Action5"); }
}

import java.lang.reflect.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Main extends JFrame implements ActionListener, MouseListener {

  static void exit(String s) { System.out.println(s); System.exit(1); }

  Method currAction = null;   // bieżąca metoda obsługi
  Class actionClass = null;   // klasa obsługi
  Object actionObject = null; // obiekt obsługi
  JPopupMenu popUp = null;    // menu kontekstowe z wyborem obsługi


Main() {
  super("Test refleksji");
  try {
    actionClass = Class.forName("ActionsSet");
    actionObject = actionClass.newInstance();
  }  catch(Exception exc) {
         exit("Wadliwa klasa obsługi");
  }

  JButton b = new JButton("Akcja");
  b.setFont(new Font("Dialog", Font.BOLD, 24));
  b.addActionListener(this);
  b.addMouseListener(this);
  getContentPane().setLayout(new FlowLayout());
  getContentPane().add(b);
  popUp = new JPopupMenu();
  createMenuItems();
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  pack();
  show();
}

void createMenuItems() {
  Method m[] = null;
   try {
       m = actionClass.getDeclaredMethods();
   } catch(Exception exc) {
        exit("Niedostępna info o metodach klasy obsługi");
   }

  for (int i = 0; i < m.length; i++) {
     String name = m[i].getName();
     JMenuItem mi = new JMenuItem(name);
     mi.addActionListener(this);
     popUp.add(mi);
  }
}


void setCurrentAction(String action) {
  Class args[] = {};
  try {
     currAction = actionClass.getMethod(action, args);
    } catch(Exception exc) { exit("Nieznana metoda obsługi"); }
}

public void actionPerformed(ActionEvent e) {
   Object src = e.getSource();
   if (src instanceof JMenuItem)
      setCurrentAction(((JMenuItem) src).getText());
   else {
     try {
       Object args[] = { };
       currAction.invoke(actionObject, args);  // wywołanie metody obsługi
     }  catch(Exception exc) {
          JOptionPane.showMessageDialog(null, "Akcja na przycisku nieustalona!");
     }
   }
}

public void mousePressed(MouseEvent e) {
  showPopup(e);
}
public void mouseReleased(MouseEvent e) {
  showPopup(e);
}

public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseClicked(MouseEvent e) {}

private void showPopup(MouseEvent e)  {
  if (e.isPopupTrigger()) popUp.show(e.getComponent(), e.getX(), e.getY());
}

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

}

3.4. Pojęcie JavaBean

• jakie ma właściwości? jakie metody służą do ich pobierania i ustalania?
• jakie obsługuje zdarzenia? jakie zdarzenia mogą się mu przytrafiać?
• jakie metody udostępnia otoczeniu (eksportuje)?

• uzgodnionym protokole. dotyczącym informacji o ziarnie (standardowe wzorce deklaracji metod i/lub klasy informacyjne)
• standardowych środkach pobierania informacji (introspekcja - realizowana przez klasę Introspector z pakietu java.beans)
• standardowych środkach dostosowania obiektu

3.5.  Właściwości i akcesory

• stosuje ogólnie przyjęte wzorce sygnatur metod  i/lub uzupełniona jest przez dodatkową specjalną klasę opisującą "niestandardowe" informacje o ziarnie (implementacja interfejsu BeanInfo)
• zapewnia serializację obiektów
• zawiera konstruktor bezparametrowy
• uzwględnia działania w środowisku wielowątkowym (do obiektu klasy może równocześnie odwoływać się kilka wątków)

3.6.  Nasłuch i wetowanie zmian właściwosci

• nazwę właściwości -  String getPropertyName()
• starą wartość własciwości  (przed zmianą) – Object getOldValue()
• nową wartość własciwości – Object getNewValue()

• właściwości związanych -  firePropertyChange
• właściwości ograniczanych -  fireVetoableChange słuchaczy.
• a także metod przyłączanai i odłączania słuchaczy tych zmian (addNNNListener, removeNNListener).

class Ziarno .... {

  //wsparcie
  private PropertyChangeSupport chg = new PropertyChangeSupport(this);

  String text;    // to będzie właściwośc związana o nazwie "text"
  ...
// setter
synchronized void setText(String newTxt) { // pamiętamy o wielowątkowości!

    String oldTxt =  text;   // stara wartość
    text = newTxt;           // ustalenie nowej wartości
     // powiadomienie
    chg.firePropertyChange("text", oldTxt, newTxt);
}
....

// metody dodawania i usuwania słuchaczy
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
 chg.addPropertyChangeListener(l);
 }

public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
 chg.removePropertyChangeListener(l);
 }
...
}

class Ziarno .... {

  //wsparcie
  private VetoableChangeSupport veto = new VetoableChangeSupport(this);

  String text;    // to będzie właściwośc ograniczana o nazwie "tekst"
  ...
// setter

synchronized void setText(String newTxt)  throws PropertyVetoException
 {
    String oldTxt =  text;  // stara wartość

     // wywołujemy metodę fireVotoableChange, która z kolei
     // wywołuje metody vetoableChange zarejestrowanych słuchaczy
     // jeśli któraś z nich zgłasza veto, setter kończy działanie
     // a wyjątek PropertyVetoException jest przekazywany do obsługi
     //  przez metodę wywołującą setText

     veto.fireVetoableChange("tekst", oldTxt, newTxt);

     // Tylko jeśli nikt nie zawetował zmiany:

     text = newTxt;   // ustalenie nowej wartości
}
....
// metody dodawania i usuwania słuchaczy

public synchronized void addVetoableChangeListener(PropertyChangeListener l) {
 veto.addVetoableChangeListener(l);
 }

public synchronized void removeVetoableChangeListener(PropertyChangeListener l) {
 veto.removeVetoableChangeListener(l);
 }
...
}

// Uwaga: wsystkie klasy  zdarzeniowe i interfejsy nasłuchu
// dla właściwości znajdują się w pakiecie java.beans.

3.7.  JavaBean - przykład praktyczny

// Klasa Counter

import java.awt.event.*;
import java.beans.*;
import java.io.*;

public class Counter implements Serializable {

  private int count = 0;    // właściwość count

  // Pomocniczy obiekt do prowadzenia listy słuchaczy zmian właściwości oraz
  // propagowania zmian  wśród zarejestrowanych złuchaczy
   private PropertyChangeSupport propertyChange = new PropertyChangeSupport(this);


  // Konstruktory

  public Counter() {
    this(0);
  }

  public Counter(int aCount) {
    setCount( aCount );
  }


  // Metody przyłączania i odłączania słuchaczy zmian właściwości

  public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
    propertyChange.addPropertyChangeListener(listener);
  }

  public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
    propertyChange.removePropertyChangeListener(l);
  }

  // Proste metody zwiększania i zmniejszania licznika

  public void increment() {
    setCount(getCount()+1);
  }

  public void decrement() {
    setCount(getCount()-1);
  }


  // Getter właściwości "count"
  public int getCount() {
    return count;
  }

  // Setter właściowści "count"
  public synchronized void setCount(int aCount) {
    int oldValue = count;
    count = aCount;

    // wywołanie metody firePropertChange z klasy PropertyChangeSupport
    // powoduje wygenerowanie zdarzenia PropertyChangeEvent i rozpropagowanie
    // go wśród wszystkich przyłączonych słuchaczy, ale tylko wtedy, gdy nowa
    // wartość właściwości różni się od starej wartości

    propertyChange.firePropertyChange("count", new Integer(oldValue),
                                            new Integer(aCount));
  }

}

//Klasa CounterView
//Widok licznika przedstawiamy w postaci etykiety

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


public class CounterView extends JLabel implements PropertyChangeListener {


  // Konstruktor domyślny: inicjalizuje etykietę tekstem "0"
  CounterView()  {
     this("0");
  }

  // Konstruktor inicjalizujący etykietę podanym tekstem
  CounterView(String lab) {
     super(lab);
     setOpaque(true);   // etykieta nie przezroczysta
       // ramka
     setBorder(BorderFactory.createLineBorder(Color.black));
       // rozmiary i wyrównanie tekstu
     setPreferredSize(new Dimension(75, 40));
     setHorizontalAlignment(CENTER);
  }

  // obługa zdarzenia PropertyChange
  public void propertyChange(PropertyChangeEvent e)  {
    Integer oldVal = (Integer) e.getOldValue(),
           newVal = (Integer) e.getNewValue();
    System.out.println("Value changed from " + oldVal + " to " + newVal);
    setText("" + newVal + "");  // pokazanie na etykiecie nowego stanu licznika
   }


}

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.*;

public class CounterControlGui extends JFrame implements ActionListener {

  Counter counter;
  JButton binc = new JButton("Increment");
  JButton bdec = new JButton("Decrement");
  JTextField txt = new JTextField(10);

  // Konstruktor otrzymuje jako argumenty obiekty typu Counter i CounterView
  // Pierwszy jest nam potrzebny do komunikacji z licznikiem, drugi - widok
  // wbudujemy w to GUI.

  CounterControlGui(Counter c, CounterView clab)  {
    counter = c;
    Container cp = getContentPane();
    cp.setLayout(new FlowLayout());
    binc.addActionListener(this);
    cp.add(binc);
    cp.add(clab);
    bdec.addActionListener(this);
    cp.add(bdec);
    txt.addActionListener(this);
    cp.add(txt);
    setDefaultCloseOperation(3);
    pack();
    show();
  }


  // Obsługa akcji
  public void actionPerformed(ActionEvent e)  {
      if (e.getSource() == txt)  {
         int n = 0;
         try  {
            n = Integer.parseInt(txt.getText());
         } catch (NumberFormatException exc)  { return; }
         counter.setCount(n);
         return;
      }
      String cmd = e.getActionCommand();
      if (cmd.equals("Increment")) counter.increment();
      else if (cmd.equals("Decrement")) counter.decrement();
      else System.out.println("Unrecognized command");
  }

}

public class Main {

 public static void main(String[] args)  {

   // Tworzymy obiekty: licznik i jego widok
   Counter counter = new Counter();
   CounterView counterView = new CounterView(""+counter.getCount());

   // Rejestrujemy widok jako słuchacza zmian licznika
   counter.addPropertyChangeListener(counterView);

   // Tworzymu GUI kontrolera i pokazujemy go
   CounterControlGui gui = new CounterControlGui(counter, counterView);
   gui.pack();
   gui.show();
  }

}

import java.beans.*;

public class CounterLimitator implements VetoableChangeListener {

// minimalne i makszymalne dopuszczalne wartości licznika
private int min, max;

CounterLimitator(int minLim, int maxLim)  {
  min = minLim;
  max = maxLim;
}

// Obsługa zdarzenia vetoableChange
// metoda może sygnalizować PropertyVetoException
public void vetoableChange(PropertyChangeEvent e)
            throws PropertyVetoException {
   Integer newVal = (Integer) e.getNewValue();
   int val = newVal.intValue();
   // Sprawdzamy, czy zmiana  licznika jest dopuszczalna,
   // jeśli nie – sygnalizujemy wyjatek  PropertyVetoException
   if (val < min || val > max)
      throw new PropertyVetoException("Niedopuszczalna zmiana wartości", e);
   }

}

public class Counter {

//...

private VetoableChangeSupport vetos = new VetoableChangeSupport(this);

public synchronized void addVetoableChangeListener(VetoableChangeListener l) {
	vetos.addVetoableChangeListener(l);
}

public synchronized void removeVetoableChangeListener(VetoableChangeListener l) {
	vetos.removeVetoableChangeListener(l);
}

// ...
}

public class Counter {

//...
public synchronized void setCount(int aCount)
                         throws PropertyVetoException {

     int oldValue = count;

     // wywołujemy metodę fireVotoableChange, która z kolei
     // wywołuje metody vetoableChange zarejestrowanych słuchaczy
     // jeśli któraś z nich zgłasza veto, setter kończy działanie
     // a wyjątek PropertyVetoException jest przekazywany do obsługi
     // przez metodę wywołującą setCount
     // (co zaznaczyliśmy w nagłówku metody przez
     // throws PropertyVetoException)

    vetos.fireVetoableChange("count", new Integer(oldValue), new Integer(aCount));

    // tylko jeśli nikt nie zawetował

    count = aCount;  // ustalamy nową wartość licznika

    // ... powiadamiamy nasłuchujących zmiany właściwości count

    propertyChange.firePropertyChange("count", new Integer(oldValue),
                                       new Integer(aCount));
}

//...
}

public class CounterControlGui .... {

....
public void actionPerformed(ActionEvent e)  {
  try  {
    if (e.getSource() == txt)  {
       int n = 0;
       try  {
          n = Integer.parseInt(txt.getText());
       } catch (NumberFormatException exc)  { return; }
       counter.setCount(n);
       return;
    }
    String cmd = e.getActionCommand();
    if (cmd.equals("Increment")) counter.increment();
    else if (cmd.equals("Decrement")) counter.decrement();
    else System.out.println("Unrecognized command");
  } catch (PropertyVetoException exc)  { // obługa wyjatku:
      System.out.println(""+ exc);       // podanie informacji
                                         //o niedopuszczalnej zmianie wartości
  }
}

//...
}

import java.beans.*;
public class Main {

 public static void main(String[] args) throws PropertyVetoException {
   Counter counter = new Counter();
   CounterView counterView = new CounterView(""+counter.getCount());
   counter.addPropertyChangeListener(counterView);

   // licznik może się zmieniać od –5 do 10
   // bo Limitator zawetuje każdą inną zmianę
   CounterLimitator clim = new CounterLimitator(-5, 10);
   counter.addVetoableChangeListener(clim);

   CounterControlGui gui = new CounterControlGui(counter, counterView);
   gui.pack();
   gui.show();
  }

}

3.8. Introspekcja

• analizę komponentów za pomocą metod refleksji przy założeniu, że stosowane są pewne standardowe wzorce nazewnictwa, umożliwiające określenie  własnściwości i ich typu, metod pobierania i ustalania tych właściwości,  rodzajóa zdarzeń,  metod rejestracji słuchaczy i nnych metod udostępnianych przez dane ziarno "na zewnątrz"
• określanie uzewnętrznianych właściwości i funkcjonalności ziarna na podstawie dowolnie specyfikowanych przez twórcę ziarna elementów, zapisywanych w odpowiedniej dla danego ziarna klasie BeanInfo.

• EventSetDescriptor[]  getEventSetDescriptors()  - zwraca tablicę deskryptorów zdarzeń
• PropertyDescriptor[]  getPropertyDescriptors()  - zwraca tablicę deskryptorów własności
• MethodDescriptor[]   getMethodDescriptors()     - zwraca tablicę deskryptorów metod
• dla każdgo deskryptora metody ParameterDescriptor[] getParameterDexriptors() - zwraca tablicę deskryptorów parametrów tej metody
  

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

public class BeanAnalyze {

  static void say(String s) { System.out.println(s); }

  public static void main(String[] arg) throws Exception {

    BeanInfo beanInfo = Introspector.getBeanInfo(Class.forName(arg[0]));

    PropertyDescriptor[] pd = beanInfo.getPropertyDescriptors();
    MethodDescriptor[] md = beanInfo.getMethodDescriptors();
    EventSetDescriptor[] evd = beanInfo.getEventSetDescriptors();

    say("Właściwości:");
    for (int i = 0; i < pd.length; i++) {
      say(pd[i].getShortDescription());
      // getReadMethod i getWriteMethod zwracają obiekty typu Method
      say(" getter: "+ pd[i].getReadMethod());
      say(" setter: "+ pd[i].getWriteMethod());
    }

    say("\nMetody:");
    for (int i=0; i<md.length; i++) {
      say(" " + md[i].getMethod());
    }

    say("\nZdarzenia:");
    for (int i = 0; i < evd.length; i++) {
      say("Zdarzenie : " + evd[i].getShortDescription());
      Method[] met = evd[i].getListenerMethods();
      say("Metody obsługi:");
      for (int j=0; j < met.length; j++)  say(" " + met[j]);
    }
  }

}

3.9. Dynamiczne pobieranie i ustalanie właściwości

public class TestBean {

  private String[] headers;
  private int count;


  public TestBean() {
  }

  public TestBean(int n) {
    count = n;
  }

  public String[] getHeaders() {
    return headers;
  }

  public void setHeaders(String[] value) {
    headers = value;
  }

  public int getCount() {
    return count;
  }

  public void setCount(int value) {
    count = value;
  }

}

import java.beans.*;
import java.awt.*;
import javax.swing.*;

public class DynamicExec {

  public static void main(String[] args) throws Exception {

    Statement stmt;
    Expression expr;

    JButton b = new JButton();

    // Na rzecz przycisku wołamy dynamicznie metodę setText
    // z argumentem "Przycisk"
    stmt = new Statement(b, "setText", new Object[] { "Przycisk" });
    stmt.execute();

    // Jaki wynik? Najpierw statyczne odwołanie
    System.out.println("Tekst na przycisku 1: " + b.getText());

    // Teraz dynamicznie: stwórzmy wyrażenie, którego wynikiem
    // jest wynik podanej metody z podanymi argumentami wywolanej
    // na rzecz b
    // Uwaga: brak argumentów - czyli tablica Object o rozmiarze 0
    expr = new Expression(b, "getText", new Object[0]);

    // Jeżeli wyrażenie expr nie ma jeszcze wyniku
    // metoda getValue() wywołuje podaną w wyrażeniu metodę
    // i zwraca jej wynik; w przeciwnym razie zwraca
    // ustalony wczesniej wynik

    String txt = (String) expr.getValue();
    System.out.println("Tekst na przycisku 2: " + txt);

    // Możemy też stosować klasy Statement i Expression
    // wobec naszych własnych klas JavaBeans

    TestBean tbean = new TestBean();

    // Uwaga: przy przekazywaniu argumentów i zwrocie wynikow
    // następują automatyczne przeksztalcenia pomiedzy
    // typami prostymi i odpowiadającymi im klasami opakowującymi
    // np. int - Integer  - setCount wymaga argumentu int,
    // my podajemy Integer

    stmt = new Statement(tbean, "setCount",
                               new Object[] { new Integer(22) });
    stmt.execute();

    // Jaka jest teraz wartość właściwości count
    // I znowu: getCount() zwraca int, my odbieramy Integer

    expr = new Expression( tbean, "getCount", new Object[0] );
    Integer val = (Integer) expr.getValue();

    System.out.println("Wartość count: " + val);

    // Czy możemy działać na tabliach? Ależ tak!

    stmt = new Statement(tbean, "setHeaders",
                         new Object[] { new String[] { "a", "b" } }
                        );
    stmt.execute();

    expr = new Expression(tbean, "getHeaders", new Object[0]);
    String[] hdr = (String[]) expr.getValue();

    System.out.println("Ustalone nagłówki");
    for (int i=0; i<hdr.length; i++)
       System.out.println(hdr[i]);

    // Możemy nawet stworzyć nowy obiekt
    // używając specjalnej nazwy metody - new  (oczywiście)

    expr = new Expression(TestBean.class, "new",
                          new Object[] { new Integer(111) }
                         );
    TestBean tb2 = (TestBean) expr.getValue();

    expr = new Expression (tb2, "getCount", new Object[0]);
    val = (Integer) expr.getValue();

    System.out.println("W nowym obiecie count = " + val);

  }
}

3.10. Serializacja JavaBeans

import java.beans.*;
import java.awt.*;
import javax.swing.*;
import java.io.*;

public class SerialBean {

  String fname = "test.xml";

  public SerialBean() {
    JButton b = new JButton("Kąśliwie wróbel ćwierkał");
    b.setBackground(Color.red);
    b.setForeground(Color.yellow);

    try {
      XMLEncoder enc = new XMLEncoder(
                         new BufferedOutputStream(
                            new FileOutputStream(fname)
                            )
                      );
      enc.writeObject(b);
      enc.close();
    } catch (FileNotFoundException exc) {
        exc.printStackTrace();
        System.exit(1);
    }
    nowReadAndReport();
  }

  private void nowReadAndReport() {
    try {
      XMLDecoder dec = new XMLDecoder(
                          new BufferedInputStream(
                              new FileInputStream(fname)));
      Object obj = dec.readObject();
      JButton b = (JButton) obj;
      dec.close();
      System.out.println("Napis na przycisku: " + b.getText());
      System.out.println("Kolor tła: " + b.getBackground());
      System.out.println("Kolor tekstu : " + b.getForeground());

    } catch (FileNotFoundException exc) {
        exc.printStackTrace();
        System.exit(1);
    }
  }



  public static void main(String[] args) {
    SerialBean serialbean = new SerialBean();
  }


}

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.1-rc" class="java.beans.XMLDecoder">
 <object class="javax.swing.JButton">
  <string>KÄĹ>liwie wrĂłbel Ä+wierkaĹ'</string>
  <void property="background">
   <object class="java.awt.Color">
    <int>255</int>
    <int>0</int>
    <int>0</int>
    <int>255</int>
   </object>
  </void>
  <void property="foreground">
   <object class="java.awt.Color">
    <int>255</int>
    <int>255</int>
    <int>0</int>
    <int>255</int>
   </object>
  </void>
 </object>
</java>

3.11. Inne zagadnienia związane z JavaBeans

• przystosowanie ziaren: klasy-edytory właściwości używane m.in. w środowiskach wizualnych
• tworzenie klas BeanInfo, opisujących informacje niedostępną metodami refleksji,
• koteksty (BeanContext) - swoiste kontenery, dostarczające generalnych mechanizmów i serwisów dla JavaBeans.

3.12. Ćwiczenia i zadania

1. Za pomocą refleksji wypisać nazwy i typy parematrów wszystkich dostępnych metod wybranej klasy ze standardowcyh pakietów Javy.
2. Napisać program, który na podstawie podanych w pliku tgekstowym informacji tworzy okno z komponentami i ustala ich właściwości. Wykorzystać refleksję.
3. Stworzyć klasę-ziarno, reprezentującą obiekty - konta bankowe. Oczywiście będziemy tu mieli wpłaty i wypłaty. Napisać program symulacyjny, w którym obniżenie stanu konta poniżej zera jest automatycznie raportowane, a wypłaty powodujące przekroczenie limitu przyznanego kredytu - automatycznie odrzucane.
4. Za pomocą mechanizmów serializacji JavaBeans zapewnić utrwalanie i odtwarzanie informacji o kontach.