java中的事件機制的參與者有3種角色：

1.event object：就是事件產生時具體的“事件”，用于listener的相應的方法之中，作為參數，一般存在與listerner的方法之中

2.event source：具體的接受事件的實體，比如說，你點擊一個button，那么button就是event source，這樣你必須使button對某些事件進行相應，你就需要注冊特定的listener，比如說MouseEvent之中的MouseClicked方法，這是他就必須有了add方法

3.event listener：具體的對監聽的事件類，當有其對應的event object產生的時候，它就調用相應的方法，進行處理。在windows程序設計里邊這種相應使用callback機制來實現的

先看看jdk提供的event包：

public interface EventListener：所有事件偵聽器接口必須擴展的標記接口。

public class EventObject extends Object implements Serializable所有事件狀態對象都將從其派生的根類。 所有 Event 在構造時都引用了對象 "source"，在邏輯上認為該對象是最初發生有關 Event 的對象。

在Java2處理事件時，沒有采用dispatchEvent()-postEvent()-handleEvent()方式，采用了監聽器類，每個事件類都有相關聯的監聽器接口。事件從事件源到監聽者的傳遞是通過對目標監聽者對象的Java方法調用進行的。 ? ? ?對每個明確的事件的發生，都相應地定義一個明確的Java方法。這些方法都集中定義在事件監聽者(EventListener)接口中，這個接口要繼承 java.util.EventListener。

實現了事件監聽者接口中一些或全部方法的類就是事件監聽者。 ? ? ?伴隨著事件的發生，相應的狀態通常都封裝在事件狀態對象中，該對象必須繼承自java.util.EventObject。事件狀態對象作為單參傳遞給應響應該事件的監聽者方法中。發出某種特定事件的事件源的標識是：遵從規定的設計格式為事件監聽者定義注冊方法，并接受對指定事件監聽者接口實例的引用。 ? ?開始之前首先問個問題：您熟悉java.util.EventObject 和java.util.EventListener兩個類以及他們已有的子類嗎？

如果你已經能夠熟練使用jdk為我們提供的事件監聽器，并且很熟悉MouseEvent, KeyEvent, WindowEvent等等這些jdk為我們準備好的事件，那么想必你對java的事件機制已經有所理解。但是也許你還是覺得雖然用起來沒什么問題，但是原理還是有些糊涂，那么下面我們再進一步自己實現這些事件和監聽器，我們把這個取名為自定義事件。 ? 其實自定義事件在java中很有用處，我們有的時候想讓自己的程序產生一個事件，但有不希望(或者不可能)用鼠標，鍵盤之類的輸入設備進行操作，比如你寫一個應用程序，在這個程序中一旦收到郵件就對郵件進行相關處理，對于“收到郵件”這個事件，jdk中就沒有定義。對于這樣的事件，以及對于這樣的事件的監聽器，我們只能自己動手完成了。

其實呢，java事件處理機制就是觀察者模式，我這里詳細的整理一下，在并發編程中，動不動就給某一個主題注冊一個監聽，然后當主題狀態發生變化的時候，監聽就會被觸發。好了，廢話不多說了，我貼出幾篇代碼好了。

第一步：

/**

*

*/

package test;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 前面我已經整理了觀察者模式，這里對照這個設計模式來整理下java事件

* 這里先寫個最簡單的模擬

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一個被觀察者，然后在初始化一個觀察者

// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發

Observable observable = new Observable();

Observer observer = new Observer();

observable.setObserver(observer);

observable.test();//事件被成功的觸發了

}

}

//這個模擬被觀察者

class Observable

{

//綁定到被觀察者上面的觀察者

private Observer observer;

//被觀察者對外面提供的操作

public void test()

{

observer.test();

}

public Observer getObserver()

{

return observer;

}

public void setObserver(Observer observer)

{

this.observer = observer;

}

}

// 這個模擬觀察者

class Observer

{

// 這個模擬事件

public void test()

{

System.out.println("這里就是事件。。。");

}

}

第二步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。

* 現在綁定多個觀察者。

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一個被觀察者，然后在初始化2個觀察者

// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發

Observable observable = new Observable();

Observer observer1 = new Observer();

Observer observer2 = new Observer();

observable.registObserver(observer1);

observable.registObserver(observer2);

//調用外部事件，看看觀察者里面的事件執行了沒有

observable.notifyObserver("被觀察者觸發了操作了呢");

}

}

// 這個模擬被觀察者

class Observable

{

// 綁定到被觀察者上面的觀察者

private List observers = new ArrayList();

// 添加一個觀察者到被觀察者身上

public void registObserver(Observer observer)

{

observers.add(observer);

}

// 從綁定的觀察者集合中去掉當前這個

public void removeObserver(Observer observer)

{

observers.remove(observer);

}

// 定義外部執行

public void notifyObserver(String str)

{

for (Observer observer : observers)

{

observer.test(str);

}

}

}

// 這個模擬觀察者

class Observer

{

// 這個模擬事件

public void test(String str)

{

System.out.println("這里就是事件-->" + str);

}

}

第三步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。

* 現在綁定多個觀察者。現在在稍微復雜一點，觀察者和被觀察者都面向接口編程，里面提供多個實現

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一個被觀察者，然后在初始化2個觀察者

// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發

Iobservable observable = new Observable();

Iobserver observer = new Observer();

Iobserver observer1 = new Observer1();

observable.registObserver(observer);

observable.registObserver(observer1);

// 調用被觀察者的外部事件，看看觀察者里面的事件執行了沒有

observable.notifyObserver("被觀察者觸發了操作了呢");

}

}

// 被觀察者對外提供的接口，其實這里定義成抽象類，也就是模板好一點。

interface Iobservable

{

// 綁定到被觀察者上面的觀察者

public List observers = new ArrayList();

// 添加一個觀察者到被觀察者身上

void registObserver(Iobserver observer);

// 從綁定的觀察者集合中去掉當前這個

void removeObserver(Iobserver observer);

// 定義外部執行

public void notifyObserver(String str);

}

// 觀察者對外提供的接口。

interface Iobserver

{

// 這個模擬事件

public void test(String str);

}

// 這個模擬被觀察者

class Observable implements Iobservable

{

public void registObserver(Iobserver observer)

{

observers.add(observer);

System.out.println("這里添加一個被觀察者-->" + observer.getClass());

}

public void removeObserver(Iobserver observer)

{

observers.remove(observer);

System.out.println("這里溢出一個被觀察者-->" + observer.getClass());

}

public void notifyObserver(String str)

{

for (Iobserver observer : observers)

{

observer.test(str);

}

}

}

// 這個模擬觀察者0

class Observer implements Iobserver

{

public void test(String str)

{

System.out.println("這里就是Observer事件-->" + str);

}

}

// 這個模擬觀察者1

class Observer1 implements Iobserver

{

public void test(String str)

{

System.out.println("這里就是Observer1事件-->" + str);

}

}

第四步：

/**

*

*/

package test;

import java.util.ArrayList;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年8月31日 下午3:07:34

* @Description:

* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。

* 現在綁定多個觀察者。現在在稍微復雜一點，觀察者和被觀察者都面向接口編程，里面提供多個實現。

* 最后現在提供一個最完美的觀察者模式，其實和我前面那篇博客寫的差不多

*/

public class Util

{

public static void main(String[] args)

{

// 首先初始化一個被觀察者，然后在初始化2個觀察者

// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發

Iobservable observable = new Observable();

Iobserver observer = new Observer();

Iobserver observer1 = new Observer1();

observable.registObserver(observer);

observable.registObserver(observer1);

// 調用被觀察者的外部事件，看看觀察者里面的事件執行了沒有

System.out.println("===========華麗麗的分割線=============");

observable.notifyObserver("LinkinPark...");

}

}

// 被觀察者對外提供的接口，其實這里定義成抽象類，也就是模板好一點。

abstract class Iobservable

{

// 綁定到被觀察者上面的觀察者

public List observers = new ArrayList();

// 添加一個觀察者到被觀察者身上

abstract void registObserver(Iobserver observer);

// 從綁定的觀察者集合中去掉當前這個

abstract void removeObserver(Iobserver observer);

// 通知給觀察者，讓其開始做相關處理

public void notifyObserver(String str)

{

for (Iobserver observer : observers)

{

observer.test(str);

}

}

}

// 觀察者對外提供的接口。

interface Iobserver

{

// 這個模擬事件

public void test(String str);

}

// 這個模擬被觀察者

class Observable extends Iobservable

{

private String name;

public String getName()

{

return name;

}

// 在給這個被觀察者重新設值name的時候，也就說現在觀察者狀態發生改變了，那么就要通知給觀察者，讓他也來做相關的處理

public void setName(String name)

{

this.name = name;

notifyObserver(name);

}

public void registObserver(Iobserver observer)

{

observers.add(observer);

System.out.println("這里添加一個被觀察者-->" + observer.getClass());

}

public void removeObserver(Iobserver observer)

{

observers.remove(observer);

System.out.println("這里移除一個被觀察者-->" + observer.getClass());

}

}

// 這個模擬觀察者0

class Observer implements Iobserver

{

public Observer()

{

System.out.println("Observer:觀察者原來的name-->" + getName());

}

private String name = "Observer";

public String getName()

{

return name;

}

public void setName(String name)

{

this.name = name;

}

public void test(String str)

{

System.out.println("Observer:原來的name-->" + getName());

setName(str);

System.out.println("被觀察者狀態改變后本地的同步name-->" + getName());

}

}

// 這個模擬觀察者1

class Observer1 implements Iobserver

{

public Observer1()

{

System.out.println("Observer1:觀察者原來的name-->" + getName());

}

private String name = "Observer1";

public String getName()

{

return name;

}

public void setName(String name)

{

this.name = name;

}

public void test(String str)

{

System.out.println("Observer1:原來的name-->" + getName());

setName(str);

System.out.println("被觀察者狀態改變后本地的同步name-->" + getName());

}

}

最后一步：java事件監聽了呢。

package test;

import java.util.ArrayList;

import java.util.EventListener;

import java.util.EventObject;

import java.util.Iterator;

import java.util.List;

/**

* @author LinkinPark

* @date 2015年9月1日 下午1:46:52

* @Description: java事件監聽機制

*/

public class Linkin

{

// 初始化主題-->被觀察者

DemoSource source = new DemoSource();

// 初始化監聽-->觀察者

DemoListener Listener1 = new Listener1();

DemoListener Listener2 = new Listener2();

public Linkin()

{

source.addDemoListener(Listener1).addDemoListener(Listener2).addDemoListener(new DemoListener()

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("匿名內部類收到主題推送-->" + demoEvent.getSource().getClass());

}

});

System.out.println("主題原來的狀態-->" + name);

}

private String name = "nameOld";

/**

* @return the name

*/

public String getName()

{

return name;

}

/**

* @param name the name to set

*/

public void setName(String name)

{

this.name = name;

System.out.println("主題現在的狀態-->" + name);

source.notifyDemoEvent();

}

public static void main(String[] args)

{

new Linkin().setName("nameNew");

}

}

// 就是事件產生時具體的“事件”，用于listener的相應的方法之中，作為參數，一般存在與listerner的方法之中

class DemoEvent extends EventObject

{

private static final long serialVersionUID = 1L;

Object obj;

public DemoEvent(Object source)

{

super(source);

obj = source;

}

public Object getSource()

{

return obj;

}

}

// 具體的對監聽的事件類，當有其對應的event?object產生的時候，它就調用相應的方法，進行處理。

interface DemoListener extends EventListener

{

void demoEvent(DemoEvent demoEvent);

}

// 這個相當于觀察者

class Listener1 implements DemoListener

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("Listener1監聽收到了主題的推送消息" + demoEvent.getSource());

}

}

// 這個相當于觀察者

class Listener2 implements DemoListener

{

@Override

public void demoEvent(DemoEvent demoEvent)

{

System.out.println("Listener2監聽收到了主題的推送消息" + demoEvent.getSource());

}

}

// 具體的接受事件的實體，也就是觀察者模式中的被觀察者。比如說，你點擊一個button，那么button就是event source，

// 這樣你必須使button對某些事件進行相應，你就需要注冊特定的listener，比如說MouseEvent之中的MouseClicked方法，這是他就必須有了add方法

class DemoSource

{

private List repository = new ArrayList();

DemoListener dl;

public DemoSource()

{

}

// 添加監聽

public DemoSource addDemoListener(DemoListener dl)

{

repository.add(dl);

return this;

}

// 狀態改變被觸發

public void notifyDemoEvent()

{

Iterator it = repository.iterator();

while (it.hasNext())

{

dl = (DemoListener) it.next();

dl.demoEvent(new DemoEvent(this));

}

}

}

總結

以上是生活随笔為你收集整理的java dispatchevent_java事件处理机制的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。