Penanganan Kejadian (event handling)

5. Penanganan Kejadian (event handling)

package :
java.awt.event dan javax.swing.event

agar komponen dapat menangani kejadian, kompnen tsb harus :
1. didaftarkan menjadi pendengar (listener), contoh :

JButton tombolSelesai = new JButton("Selesai");
tombolSelesai.addActionListener(this);

scra umum bentuk metode nya :
    addxxxListener()

2. Harus mengimplementasikan suatu interface listener
3. Membuat object suatu kelas yang merupakan kelas adapter
4. Menulis kode pada metode penanganan kejadian

kelas adapter adalah kelas bawaan java yang mengandung nama adapter 
                     dibagian belakang dan merupakan kelas abstrak
        yang merupakan implementasi dari suatu interface listener.

contoh :
windowAdapter = kelas abstrak yang mengimplementasi interface WindowListener
MouseAdapter = ----" ---- MouseListener

contoh program :

bSubmit.addActionListener(new ActionListener() 
        {
            public void actionPerformed(ActionEvent e) 
            {
                oNama.setText(tNama.getText());
            }
        } );
kelas dan interface pada java :

kejadian dan interface  |    metode --> listener     |     Komponen
------------------------------- |-----------------------------------------    |-------------------------------------
ActionEvent       |    addActionListener     |     JButton, JList dll
ActionListener      |            |    
--------------------------------|-------------------------------------------|--------------------------------------
 AdjusmentEvent      |              |
AdjustmentListener      |     addAdjusmentListener |     JScrollBar
------------------------------- | -------------------------------------------| ------------------------------------
 dll.

Listener dan metode penanganan kejadian :

Listener / Adapter      |     Metode 
--------------------------    | -------------------------------------------------------
ActionListener     |     actionPerformed(ActionEvent)
--------------------------    | -------------------------------------------------------
AdjusmentListener     |     adjustmentValueChanged (AdjustmentEvent)
--------------------------    | -------------------------------------------------------
dll.


Listener         Interface             Listener Methods 

ActionEvent     ActionListener         actionPerformed(ActionEvent) 
ItemEvent     ItemListener         itemStateChanged(ItemEvent) 
MouseEvent     MouseListener         mousePressed(MouseEvent) 
                        mouseReleased

(MouseEvent) 
                        mouseEntered(MouseEvent) 
                        mouseExited(MouseEvent) 
                        mouseClicked(MouseEvent) 
                      MouseMotionListener 

mouseDragged(MouseEvent) 



konsep laen :

Dalam event handling pada Java ada empat bagian penting yang harus diketahui:

1.Event Object merupakan object yang mendiskripsikan sebuah event yang di-

trigger oleh event source.

2.Event Handler merupakan method yang menerima event object dan melakukan 

respond yang sesuai dengan event object tersebut.

3.Event Listener merupakan interface yang akan meng-handle event yang terjadi. 

setiap type event mempunyai interface yang bersesuaian. Listener tersebut harus 

diimplementasikan oleh class yang akan meng-handle event

4.Event Source merupakan pembangkit / trigger sebuah event objects
setiap event object mempunyai  type event yang berbdea beda. 

sehingga kita harus menentukan type event sebelum menentukan jenis interface 

listener. karena setiap type event mempunyai jenis interface listener yang 

bersesuaian.

berikut ini type type event yang ada di Java :

1.ActionEvent
2.ItemEvent
3.WindowEvent
4.ContainerEvent
5.ComponentEvent
6.FocusEvent
7.TextEvent
8.KeyEvent
9.MouseEvent
10.AdjustmentEvent

Berikut ini Interface Listener

1.ActionListener
2.ItemListener
3.WindowListener
4.ContainerListener
5.ComponentListener
6.FocusListener
7.TextListener
8.KeyListener
9.MouseListener
10.MouseMotionListener
11.AdjustmentListener

Berdasarkan tulisan diatas, setiap type event mempunyai satu jenis interface listener 

kecuali MouseEvent yang mempunyai dua jenis interface listener. dan setiap 

interface mempunyai method abstract yang harus di override class yang meng-

impletasikan interface. 


event listener dan event handler terdapat pada package java.awt.event

Bagaimana event handling dalam Java? ada tiga langkah penting dalam event 

handling

1.Deklarasikan class yang akan meng-handle event yang terjadi dan tuliskan code 

yang menyatakan class tersebut meng-implement interface listener
2.Event source mendaftarkan sebuah listener melalui method add<type>Listener
3.Kode yang mengimplementasikan method pada interface listener pada class yang 

akan meng-handle event. [ Override ]

Contoh program sederhana :

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

public class Penjumlahan2Field extends JFrame
{
    JLabel labelData1,labelData2,labelHasil;
    JTextField field1,field2,field3;
    JButton button;
    
    public Penjumlahan2Field()
    {
        setLayout(null);
        labelData1=new JLabel("Data 1 = ");
        field1=new JTextField(8);
        labelData2=new JLabel("Data 2 = ");
        field2=new JTextField(8);
        labelHasil=new JLabel("Hasil = ");
        field3=new JTextField(8);        
        button=new JButton("+");
        
        labelData1.setBounds(10,10,80,25);
        field1.setBounds(65,10,80,25);
        labelData2.setBounds(10,40,80,25);
        field2.setBounds(65,40,80,25);
        labelHasil.setBounds(10,70,80,25);
        field3.setBounds(65,70,80,25);
        button.setBounds(65,120,50,25);
        
        add(labelData1);
        add(field1);
        add(labelData2);
        add(field2);
        add(labelHasil);
        add(field3);
        add(button);
        
        ActionListener listener = new Penjumlahan2Field.Handler();
        button.addActionListener(listener);    
    }
    
    class Handler implements ActionListener{
        public void actionPerformed(ActionEvent e){
            String s = e.getActionCommand();
            
            if(s.equals("+")){
                String data1=field1.getText();
                String data2=field2.getText();
                
                int a=Integer.parseInt(data1);
                int b=Integer.parseInt(data2);        

        
                int hasil=a+b;
                field3.setText(Integer.toString(hasil));
            }
        }
    }
    
    public static void main(String [] args)
    {
        Penjumlahan2Field frame=new Penjumlahan2Field();
        frame.setTitle("Penjumlahan");
        frame.setSize(200,200);
        //frame.setLocationRelationTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

1.       Class-class adapter

Konteks:
- Diinginkan untuk menggunakan suatu class dengan antarmuka (method-method public) tertentu tanpa mengubah definisi class tersebut. Class ini kita sebut adaptee.
- Konteks permasalahan dimana kita ingin menggunakan class ini membutuhkan antarmuka yang berbeda dari yang dimiliki class adaptee. Antarmuka yang diperlukan untuk ini kita sebut target.
- Antarmuka untuk target dan antarmuka yang dimiliki adaptee secara konsep berkaitan.

Solusi:
- Antarmuka yang dibutuhkan client (target) didefinisikan sebagai interface dengan method-method yang dibutuhkan untuk menyelesaikan tugas.
- Definisikan sebuah class adapter yang mengimplementasikan interface target ini.
- Class adapter memiliki referensi terhadap objek adaptee (relasi compose a.k.a HAS_A). Class adapter menerjemahkan method yang dideklarasikan pada interface target ke dalam method dari adaptee.
- Client membungkus objek adaptee ke dalam objek adapter. Client melaksanakan tugasnya dengan memanggil method adapter, dan adapter menerjemahkannya dengan memanggil method adaptee yang bersesuaian.

Contoh:
Java Library:
Dalam Java, System.in membaca rentetan byte yang masuk ke dalam komputer (input stream standar). Rentetan byte ini terkandung dalam field System.in yang memiliki tipe data InputStream. Input dari keyboard merupakan karakter yang dikodekan dalam byte-byte yang dikirim oleh keyboard. Dalam program console, kita ingin membaca input dari keyboard sebagai karakter, bukan byte. Untuk itu, kita memakai objek InputStreamReader untuk menerjemahkan byte yang dibaca dari keyboard menjadi karakter.

CODE: SELECT ALL

InputStreamReader reader = new InputStreamReader(System.in);

objek InputStreamReader bertindak sebagai adapter yang menerjemahkan antarmuka (operasi) pengambilan rentetan byte input dari keyboard menjadi antarmuka (operasi) yang menghasilkan rentetan karakter. System.in bertindak sebagai objek adaptee yang melakukan "the real deal".

NB: InputStreamReader membaca karakter satu-persatu, tapi tidak bisa membaca string secara sekaligus, sehingga InputStreamReader kurang efisien -- method dari objek InputStreamReader dipanggil untuk tiap karakter yang dimasukkan lewat keyboard. Untuk meningkatkan efisiensi, pembacaan string input dari keyboard dilakukan secara buffered -- karakter yang diketikkan lewat keyboard dimasukkan ke dalam buffer terlebih dahulu untuk kemudian dibaca sekaligus dalam satu pemanggilan method.

CODE: SELECT ALL

new BufferedReader consoleInput = new BufferedReader(reader);

// atau seperti ini

new BufferedReader consoleInput = new BufferedReader(new InputStreamReader(System.in));

Pendekorasian objek InputStreamReader supaya mendukung buffered input dengan menggunakan objek BufferedRead di atas menggunakan design pattern Decorator dan tidak berkaitan dengan Adapter, atau dengan kata lain pembacaan input keyboard secara buffered dilakukan menggunakan pattern Adapter kemudian Decorator.