Prezentacja programu PowerPoint

Mariusz Chmielewski

Programowanie

Zdarzeniowe

Komponenty Swing

Delegacyjny model

zdarzeń

Obsługa zdarzeń

kpt. mgr inż. Mariusz Chmielewski

Instytut Systemów Informatycznych

Wydział Cybernetyki

Wojskowa Akademia Techniczna

Delegacyjny model obsługi zdarzeń –

Delegation Event Model

• Prosta idea : źródło (source) generuje

zdarzenie (event), które jest wysyłane
do zarejestrowanych (jednego lub
wielu) obiektów nasłuchujących
(listener);

• Obiekt nasłuchujący oczekuje na

odebranie zdarzenia. W momencie jego
odebrania wywoływana jest procedura
obsługi zdarzenia i następnie następuje
przekazanie sterowania.

• Obiekt nasłuchujący musi zarejestrować

się do nasłuchiwania danego typu
zdarzeń w źródle. Ten fakt bezpośrednio
pozwala identyfikować tylko te obiekty
nasłuchujące które jawnie
zadeklarowały się do nasłuchiwania
zdarzeń danego typu z danego źródła.

• Zaletą tego rozwiązania jest również

separacja kodu obsługi (logiki)
przetwarzania zdarzeń oraz logiki
interfejsu generującej te zdarzenia;

• Element interfejsu użytkownika jest w

stanie delegować kod obsługi zdarzeń
do innych fragmentów kodu:

– Jednej wspólnej klasy obsługi zdarzeń

(klasa obsługująca zdarzenia dla grupy
przycisków budowanego GUI);

– Specjalizowanej klasy obsługi kojarzonej z

danym komponentem (klasa specjalizująca
się w obsłudze zdarzeń dla pojedynczego
przycisku);

Delegacyjny model obsługi zdarzeń –

Delegation Event Model

Zdarzenia

• W modelu delegacyjnym zdarzenie

identyfikowane jest jako obiekt
opisujący aktualny stan źródła.
Zdarzenie może być definiowane jako
pewien typ sygnału stanowiący o
zmianie stanu – „coś się stało”;

• Zdarzenie jest obiektem

generowanym przez zewnętrzne
akcje użytkownika takie jak ruchy
myszy, kliknięcia przycisków myszy
oraz klawiatury lub zdarzenia
generowane przez system
operacyjny (timer).

• Komponent GUI na którym

wygenerowane zostało zdarzenie
jest nazywany „źródłem zdarzenia”.

Klasy zdarzeń

AWTEvent

EventObject

AdjustmentEvent

ComponentEvent

TextEvent

ItemEvent

ActionEvent

InputEvent

WindowEvent

MouseEvent

KeyEvent

ContainerEvent

FocusEvent

PaintEvent

ListSelectionEvent

Klasą bazową wszystkich zdarzeń jest

java.util.EventObj

Podklasy

EventObj

zajmują się odwzorowaniem

konkretnych typów zdarzeń dla konkretnych
typów komponentów graficznych – akcje
przycisków, zdarzenia okna aplikacji,
specjalizowane zdarzenia komponentów,
zdarzenia myszy i klawiatury.

Akcje użytkownika, źródła
zdarzeń, typy zdarzeń

Źródło

Generowane
Akcja użytkownika

zdarzenia

zdarzenie

Clicked a button

JButton

ActionEvent

Changed text

JTextComponent

TextEvent

Double-clicked on a list item

JList

ActionEvent

Selected or deselected an item

JList

ItemEvent

with a single click
Selected or deselected an item

JComboBox

ItemEvent

Mouse moved or dragged

Component

MouseEvent

Mouse pressed, released,
clicked, entered, or exited

Component

MouseEvent

Window opened, closed
iconified, deiconified, closed

Window

WindowEvent

Click a check box

JCheckBox

ItemEvent,

ActionEvent

Click a radio button

JRadioButton

ItemEvent,

. . .

ActionEvent

Rejestracja do nasłuchu

zdarzenia

Source Object

Trigger an event

Listener Object

EventObject

Event Handler

Notify listener

Generate

an event

User

action

Model delegacji zdarzeń

source: SourceClass

+addXListener(listener: XListener)

listener: ListenerClass

User

Action

Trigger an event

XListener

handler(event: XEvent)

(a) A generic source component

with a generic listener

source: JButton

+addActionListener(listener: ActionListener)

listener: CustomListenerClass

ActionListener

actionPerformed(event: ActionEvent)

(b) A JButton source component
with an ActionListener

Generyczny model - reprezentacja komponentów

GUI

source: SourceClass

+addXListener(XListener listener)

(a) Internal function of a generic source object

event: XEvent

listener1

listener2

…

listenern

handler(

Keep it a list

Invoke

listener1.handler(event)

listener2.handler(event)

…
listenern.handler(event)

An event is

triggered

source: JButton

+addActionListener(ActionListener listener)

(b) Internal function of a JButton object

event:
ActionEvent

listener1

listener2

…

listenern

handler(

Keep it a list

Invoke

listener1.actionPerformed(event)

listener2.actionPerformed(event)

…
listenern.actionPerformed(event)

An event is

triggered

Obsługa zdarzeń akcji

Obiekt nasłuchujący musi spełniać następujące

wymagania:



Musi zostać zarejestrowany w przynajmniej jednym
źródle w celu otrzymywania określonych typów
zdarzeń.



Musi implementować metody do odbierania i
przetwarzania danego typu powiadomień.



A listener object must implement the corresponding
listener interface.



Przykład: Klasa nasłuchująca dla klasy JButton musi
implementować interfejs ActionListener. Interfejs
ten zawiera metodę actionPerformed(ActionEvent
e).



Obiekt zdarzenia jest przesyłany do metody obsługi i
zawiera wszystkie potrzebne dane dotyczące źródła
zdarzenia e.getSource() oraz samego zdarzenia.

Wybrane obiekty Listener

Event Class

Listener Interface

Listener Methods (Handlers)

ActionEvent

ActionListener

actionPerformed(ActionEvent e)

ItemEvent

ItemListener

itemStateChanged(ItemEvent e)

WindowEvent

WindowListener

windowClosing(WindowEvent e)
windowOpened(WindowEvent e)

ContainerEvent

ContainerListener

componentAdded(ContainerEvent e)
componentRemoved(ContainerEvent)

MouseEvent

MouseListener

mousePressed(MouseEvent e)
mouseReleased(MouseEvent e)

MouseMotionListener

mouseDraged(MouseEvent e)
mouseMoved(MouseEvent e)

KeyEvent

KeyListener

keyPressed(KeyEvent e)
keyReleased(KeyEvent e)
keyTyped(KeyEvent e)

TexEvent

TextListener

TextValueCnanged(TextEvent e)

Prosty przykład obsługi

zdarzeń

Cel: Wyświetlenie dwóch przycisków w

oknie aplikacji. Wynikiem kliknięcia na
jeden z przycisków ma być komunikat na
ekranie.
1. Utwórz dwa przyciski – źródła
zdarzeń;

2. Dodaj przyciski do okna;
3. Zarejestruj obiekty (obiekt)

nasłuchujący dla dodanych przycisków;

4. Zaimplementuj (nadpisz) obiekt

nasłuchujący.

1. Deklaracja źródeł zdarzeń

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

public class TestActionEvent extends JFrame

implements ActionListener

{

1 krok

Deklaracja źródeł zdarzeń(2 przyciski)

private JButton jbtOK = new Jbutton(“OK”);
private JButton jbtCL = new Jbutton(“Cancel”);

2. Rejestracja do nasłuchu

// Constructor
public TestActionEvent () {
  setTitle();
  Container cp = getContentPane();
  cp.setLayout(new FlowLayout());
  //

2 krok: dodanie źródeł zdarzeń do głównego

okna

  cp.add(jbtOK);
  cp.add(jbtCL);
  //

3 krok: rejestracja obiektu nasłuchującego

;

jbtOK.addActionListener(this);

jbtCL.addActionListener(this);

}

Drugi przykład – specjalizowana klasa

obsługi zdarzeń

public class Button2Demo extends JFrame
{
private JButton jbtOK, jbtCL;
ActionListener handler = new ButtonHandler();

public Button2Demo() {

     jbtOK = new JButton(“OK”);
     jbtOK.addActionListener(handler);
     jbtCL = new JButton(“Cancel”);
     jbtCL.addActionListener(handler);
  }
...

Handling Action Events

...
//

Inner class

  class ButtonHandler implements ActionListener {
    public void actionPerformed(ActionEvent e)
    {
      if(e.getSource() == jbtOK) {
        System.out.println(“Wcisnieto OK”);
      }//if
      if(e.getSource() == jbtCL) {
        System.out.println(“Wcisnieto Cancel”);
      } //if
    }// actionPerformed()
  }//

Inner class

}// public class

4a. Implementacja obsługi jako klasy

wewnętrznej

class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent e)  {
  if(e.getSource() == jbtClear) {
     jtfString.setText(“”);
     jlResult.setText(“”);
  }//if
  if(e.getSource() == jbtCheck) {
    String str = jtfString.getText();
    Palindrome pal = new Palindreme(str);
    boolean result = pal.IsPalindrome();
    if(result) jlResult.setText(“Yes”);
    else       jlResult.setText(“No”);
  } //if
  if(e.getSource() == jbtExit) {
         System.exit(0);
  }
}// actionPerformed()
}// inner class ButtonHandler

Wykorzystanie klasy
Palindrome do weryfikacji.

Klasy anonimowe

Język Java pozwala na definiowanie
klas anonimowych, definiowanych bez
nazwy i konstruktora. Muszą one być
określane w kodzie według
następującej zasady:

new NazwaNadKlasy(arg, arg, ...)
BlokInstrukcji

gdzie:
NazwaNadKlasy jest nazwą nadklasy
definiowanej klasy anonimowej,
arg są argumentami konstruktora
nadklasy (zależnie od podanych
argumentów wywoływany jest
odpowiedni konstruktor nadklasy:
super NazwaNadKlasy(arg, arg, ...) ),
BlokInstrukcji jest blokiem instrukcji
definiujących klasę anonimową.

Przyjmuje się, że w przypadku kiedy
nie ma jawnej definicji nadklasy jest
nią klasa Object

Mariusz Chmielewski

Klasy anonimowe

•

Powyższa definicja oznacza stworzenie obiektu klasy anonimowej
dziedziczącej z klasy Contents. Zwracana referencja nowego obiektu klasy
anonimowej jest automatycznie rzutowana na klasę Contents.
Definicja klasy anonimowej jest skrótem następującej definicji:

class MyContents implements Contents {
   private int i = 11;
   public int value() {
       return i;
   }
} return new MyContents();

•

W przypadku, gdy klasa anonimowa jest podklasą klasy wewnętrznej,
definicja klasy anonimowej przyjmuje postać:

obiektZewnętrzny.new NazwaNadKlasy(arg, arg, ...) Blok

gdzie:
obiektZewnętrzny - obiekt klasy zewnętrznej zawierającej powtórną
definicję anonimowej klasy wewnętrznej. W tym przypadku wywoływany
jest konstruktor nadklasy: obiektZewnętrzny.new NazwaNadKlasy(arg, arg,
...)

Mariusz Chmielewski

Document Outline