Listeners (por debaixo dos panos)

Para entendermos como funcionam os listeners no java, vamos primeiramente explorar um design pattern conhecido como Observer. De uma simples maneira, design patterns ou padrões de projeto são (como diz o nome) padrões na maneira de estruturar o código orientado a objetos com o objetivo de promover o baixo acoplamento entre os objetos participantes.

Observer Design Pattern:

(Obs: O java já possui em seu pacote ‘java.util’ a interface ‘Observer’ e a classe ‘Observable’. Porém para efeitos didáticos mostro abaixo uma simples implementação das mesmas para que o exemplo fique mais completo.)

import java.util.List;

import java.util.ArrayList;

public class Teste {

public static void main(String[] args){

// Broker é a classe que deseja ser observada

Broker br = new Broker();

// Display é a classe que deseja observar

Display ds1 = new Display(“display1”);

Display ds2 = new Display(“display2”);

Display ds3 = new Display(“display3”);

// Registramos os displays acima criados na classe que deseja ser observada

br.addObserver(ds1);

br.addObserver(ds2);

br.addObserver(ds3);

// atualizamos dados na classe que deseja ser observada para que ela notifique as classes que a observam.

br.updateData();

}

}

// JÁ EXISTENTE NO PACOTE ‘java.util’. Interface que deve ser implementada por todo objeto que quiser observar ou ser observador de algo

interface Observer {

void update(Object value);

}

// JÁ EXISTENTE NO PACOTE ‘java.util’. Classe que deve ser extendida por todo objeto que deseja ser observado por algum observador (observer)

class Observable {

private List<Observer> observers = new ArrayList<Observer>();

public void addObserver(Observer observer){

observers.add(observer);

}

public void notifyObservers(Object value){

for(Observer observer : observers){

observer.update(value);

}

}

}

// Classe Display, deseja ser observadora ou observar algo

class Display implements
Observer {

private String displayName;

public Display(String displayName){this.displayName = displayName;}

public void update(Object val){

System.out.format(“%1$s – %2$s \n”, this.displayName,val);

}

}

// Classe Broker deseja ser observada por algum observer.

class Broker extends
Observable {

public void updateData() {

this.notifyObservers(“Informações atualizadas …”);

}

}

Output ao executar o código acima:

display1 – Informações atualizadas

display2 – Informações atualizadas

display3 – Informações atualizadas

Listener de um Jbutton no Java Swing:

import javax.swing.*;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

public class FrmButton extends JFrame{

private JButton btn = new JButton(“ClickMe”);

public FrmButton(){

this.add(btn);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

this.pack();

// Neste momento adicionamos um objeto (classe anônima que extende MouseAdapter) que receberá a notificação de que o botão no formulário foi clicado. Este objeto é o ‘observer’ da classe JButton que é observavel (observable). Ao clicar no botão no formulário JFrame, o botão notificará a classe anônima que extende de MouseAdapter para executar o seu método ‘public void mouseClicked’.

btn.addMouseListener(new MouseAdapter(){

public void mouseClicked(MouseEvent e) {

JOptionPane.showMessageDialog(null, “Você clicou no botão”, “Olá amigo!!!”,                         JOptionPane.OK_OPTION);

}

}

);

this.setVisible(true);

}

public static void main(String[] args){

new FrmButton();

}

}

Este código irá produzir o seguinte ao executá-lo:

Um simples exemplo utilizando classes internas (inner class):

O exemplo abaixo ilustra o uso de uma classe interna e abstrata (abstract inner class). Imagine que temos uma classe que representa um formulário com um botão (MyForm) e que esta classe deve disparar um evento ao se clicar no mesmo.

Para tanto, foi declarada uma class interna e abstrata chamada (Events) onde nela esta sendo declarado o(s) método(s) abstrato(s) que deverão ser implementado pela classe que utiliza a classe MyForm, que no caso seria a OuterTest2.

class MyForm {

private Events events;

public void setEvents(Events events){

this.events = events;

}

public abstract class Events {

abstract void onClick();

}

public void clickOnButton(){

events.onClick();

}

}

public class OuterTest2 {

public static void main(String args[]){

MyForm form = new MyForm();

form.setEvents(form.new Events(){

@Override

void onClick() {

System.out.println(“button clicked”);

}

});

form.clickOnButton();

}

}

Output:

button clicked

Esta entrada foi publicada em Design Pattern, Java com as etiquetas . ligação permanente.

Uma resposta a Listeners (por debaixo dos panos)

  1. Pingback: Re-aproveitando eventos no VBA – The Observer Pattern – Eventos em interfaces não dá … | Pedro Abs

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão / Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão / Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão / Alterar )

Google+ photo

Está a comentar usando a sua conta Google+ Terminar Sessão / Alterar )

Connecting to %s