java事件監聽
⑴ java如何全局監聽鍵盤事件
java提供了兩個事件偵聽介面用來管理滑鼠移動和鍵盤動作，分別是MouseMotionListener和KeyListener，可以用它們來捕捉滑鼠和鍵盤，這兩個偵聽器都有很大的限制：滑鼠監聽只有在滑鼠位於Java程序所在的窗口范圍之內才能有效，而鍵盤監聽限制更嚴格，僅當Java程序成為當前的活動窗口時才有效。很顯然，單純用Java來實現全屏幕、所有程序滑鼠和鍵盤的話動是不行的。
⑵ java中採用事件委託模型實現對事件的監聽正確嗎
正確。
java委託事件模型的使用首先由事件源發起特定事件，並將事件發送給一個或多個事件監控器。其次監控器在此過程中一直處於等待狀態，直到接收到事件，然後處理事件並返回。
事件委託模型是利用冒泡的原理，把本應該添加到某個元素上的事件委託給他的父級，從而減少DOM交互達到網頁優化。
⑶ java中事件，事件源和事件監聽器概念，使用事件監聽器驚醒事件處理的過程
事件：當用戶在界面上執行一個操作，例如按下鍵盤、拖動或者單擊滑鼠時，都將產生一個事件。Java中事件是用來描述不同類型用戶操作的對象，Java中有很多不同類型的事件。例如：單擊，雙擊，右擊，拖動，鍵盤的按下、釋放，文本域內容改變等。
事件源：產生事件的組件就是一個事件源。例如，當在一個Button上單擊滑鼠是，將產生一個ActionEvent類型的事件，而這個Button就是事件源
事件監聽器：就是調用事件處理方法的對象。當界面操作事件產生並被發送到產生事件的組件時，該組件將把事件發送給能接受和處理該事件的監聽器。
⑷ java 自定義事件的觸發及監聽
JAVA事件響應機制
1，先自定義一個事件
public class MyEvent extends java.util.EventObject{
public MyEvent(Object source)
{
super(source);
}
}
2，再自定義一個監聽器
public class MyListener implements java.util.EventListener{
//這里是當事件發生後的響應過程
public void EventActivated(MyEvent me)
{
System.out.println("事件已經被觸發");
}
}
3，以下這個類為觸發事件的事件源
public class MyObject {
private Vector vectorListeners=new Vector();
public synchronized void addMyListener(MyListener ml)
{
vectorListeners.addElement(ml);
}
public synchronized void removeMyListener(MyListener ml)
{
vectorListeners.removeElement(ml);
}
protected void activateMyEvent()
{
Vector tempVector=null;
MyEvent e=new MyEvent(this);
synchronized(this)
{
tempVector=(Vector)vectorListeners.clone();
for(int i=0;i<tempVector.size();i++)
{
MyListener ml=(MyListener)tempVector.elementAt(i);
ml.EventActivated(e);
}
}
}
//定義一個公用方法用於觸發事件
public void test()
{
activateMyEvent();
}
}
4，測試類
public class Test {
public static void main(String[] args)
{
MyObject mo=new MyObject();
//注冊該事件
mo.addMyListener(new MyListener());
//觸發該事件
mo.test();
}
}
⑸ java設計模式-回調、事件監聽器、觀察者模式
轉自( https://my.oschina.net/u/923324/blog/792857 )
背景
關於設計模式，之前筆者寫過工廠模式，最近在使用gava ListenableFuture時發現事件監聽模型特別有意思，於是就把事件監聽、觀察者之間比較了一番，發現這是一個非常重要的設計模式，在很多框架里扮演關鍵的作用。
回調函數
為什麼首先會講回調函數呢？因為這個是理解監聽器、觀察者模式的關鍵。
什麼是回調函數
所謂的回調，用於回調的函數。 回調函數只是一個功能片段，由用戶按照回調函數調用約定來實現的一個函數。 有這么一句通俗的定義：就是程序員A寫了一段程序（程序a），其中預留有回調函數介面，並封裝好了該程序。程序員B要讓a調用自己的程序b中的一個方法，於是，他通過a中的介面回調自己b中的方法。
舉個例子：
這里有兩個實體：回調抽象介面、回調者（即程序a）
回調介面（ICallBack ）
public interface ICallBack {
public void callBack();
}
回調者（用於調用回調函數的類）
public class Caller {
}
回調測試：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台輸出：
start...
終於回調成功了！
end...
還有一種寫法
或實現這個ICallBack介面類
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("終於回調成功了！");
}
}
有沒有發現這個模型和執行一個線程，Thread很像。 沒錯，Thread就是回調者，Runnable就是一個回調介面。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回調一個新線程！");
}}).start();
Callable也是一個回調介面，原來一直在用。 接下來我們開始講事件監聽器
事件監聽模式
什麼是事件監聽器
監聽器將監聽自己感興趣的事件一旦該事件被觸發或改變，立即得到通知，做出響應。例如：android程序中的Button事件。
java的事件監聽機制可概括為3點：
java的事件監聽機制涉及到 事件源，事件監聽器，事件對象 三個組件,監聽器一般是介面，用來約定調用方式
當事件源對象上發生操作時，它將會調用事件監聽器的一個方法，並在調用該方法時傳遞事件對象過去
事件監聽器實現類,通常是由開發人員編寫，開發人員通過事件對象拿到事件源，從而對事件源上的操作進行處理
舉個例子
這里我為了方便，直接使用jdk，EventListener 監聽器，感興趣的可以去研究下源碼，非常簡單。
監聽器介面
public interface EventListener extends java.util.EventListener {
//事件處理
public void handleEvent(EventObject event);
}
事件對象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一個事件源 source :"+ this.getSource());
}
}
事件源
事件源是事件對象的入口，包含監聽器的注冊、撤銷、通知
public class EventSource {
//監聽器列表，監聽器的注冊則加入此列表
private Vector<EventListener> ListenerList = new Vector<EventListener>();
//注冊監聽器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤銷注冊
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
測試執行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台顯示：
通知一個事件源 source :openWindows
通知一個事件源 source :openWindows
doOpen something...
到這里你應該非常清楚的了解，什麼是事件監聽器模式了吧。 那麼哪裡是回調介面，哪裡是回調者，對！EventListener是一個回調介面類，handleEvent是一個回調函數介面，通過回調模型，EventSource 事件源便可回調具體監聽器動作。
有了了解後，這里還可以做一些變動。 對特定的事件提供特定的關注方法和事件觸發
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("關注關閉窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一種實現方式
*/
//關注關閉事件，實現回調介面
windows.onCloseWindows(new EventListener(){
}
這種就類似於，我們的窗口程序，Button監聽器了。我們還可以為單擊、雙擊事件定製監聽器。
觀察者模式
什麼是觀察者模式
觀察者模式其實原理和監聽器是一樣的，使用的關鍵在搞清楚什麼是觀察者、什麼是被觀察者。
觀察者(Observer)相當於事件監器。有個微博模型比較好理解，A用戶關注B用戶，則A是B的觀察者，B是一個被觀察者，一旦B發表任何言論，A便可以獲得。
被觀察者(Observable)相當於事件源和事件，執行事件源通知邏輯時，將會回調observer的回調方法update。
舉個例子
為了方便，同樣我直接使用jdk自帶的Observer。
一個觀察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已經打開窗口");
}
}
}
被觀察者
Observable 是jdk自帶的被觀察者，具體可以自行看源碼和之前的監聽器事件源類似。
主要方法有
addObserver() 添加觀察者，與監聽器模式類似
notifyObservers() 通知所有觀察者
類Watched.java的實現描述：被觀察者，相當於事件監聽的事件源和事件對象。又理解為訂閱的對象 主要職責：注冊/撤銷觀察者（監聽器），接收主題對象（事件對象）傳遞給觀察者（監聽器），具體由感興趣的觀察者（監聽器）執行
/**
}
測試執行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已經關閉窗口");
}
}
});
//觸發打開窗口事件，通知觀察者
watched.notifyObservers("openWindows");
//觸發關閉窗口事件，通知觀察者
watched.notifyObservers("closeWindows");
控制台輸出：
已經打開窗口
已經關閉窗口
總結
從整個實現和調用過程來看，觀察者和監聽器模式基本一樣。
有興趣的你可以基於這個模型，實現一個簡單微博加關注和取消的功能。 說到底，就是事件驅動模型，將調用者和被調用者通過一個鏈表、回調函數來解耦掉，相互獨立。
「你別來找我，有了我會找你」。
整個設計模式的初衷也就是要做到低耦合，低依賴。
再延伸下，消息中間件是什麼一個模型？ 將生產者+服務中心（事件源）和消費者（監聽器）通過消息隊列解耦掉. 消息這相當於具體的事件對象，只是存儲在一個隊列里（有消峰填谷的作用），服務中心回調消費者介面通過拉或取的模型響應。 想必基於這個模型，實現一個簡單的消息中間件也是可以的。
還比如gava ListenableFuture，採用監聽器模式就解決了future.get()一直阻塞等待返回結果的問題。
有興趣的同學，可以再思考下觀察者和責任鏈之間的關系， 我是這樣看的。
同樣會存在一個鏈表，被觀察者會通知所有觀察者，觀察者自行處理，觀察者之間互不影響。 而責任鏈，講究的是擊鼓傳花，也就是每一個節點只需記錄繼任節點，由當前節點決定是否往下傳。 常用於工作流，過濾器web filter。
⑹ java中的事件監聽有什麼作用，怎麼用，用在什麼地方
主要用於 GUI界面 比如 對JButton進行監聽，只要加入監聽事件，就可寫你想發生的結果。如果以後從事web編程而不從事scoket編程，這幾乎沒有多大的用處。相對而言，j學習ava的事件監聽，很容易上手。
⑺ 什麼是Java的介面，如何運用介面實現事件監聽
Java介面使用interface聲明，介面用於約定對象的行為。使用介面實現事件監聽，可以定義一個如下的一個介面：
public interface Listener {
void on(Object event)
}
⑻ java監聽器原理
Java最新的事件處理方法是基於授權事件模型，事件源生成事件並將其發送至一個或多個監聽器，監聽器簡單地等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這些事件，然後返回。
事件：在授權事件模型中，事件是一個描述事件源狀態改變的對象。 通過滑鼠、鍵盤與GUI界面直接或間接交互都會生成事件。如：按下一個按鈕、通過鍵盤輸入一個字元、選擇列表框中的一項、點擊一下滑鼠等。
事件源：事件源是一個生成事件的對象
一個事件源可能會生成不同類型的事件，事件源提供了一組方法，用於為事件注冊一個或多個監聽器。
每種事件的類型都有其自己的注冊方法。一般形式為：publicvoidadd<EventType>Listener(TypeListenere)
AWT採取的事件控制過程：監聽器對象屬於一個類的實例，這個類實現了一個特殊的介面，名為「監聽者介面」
事件源是一個對象，它可以注冊一個或多個監聽器對象，並向其發送事件對象。
事件源將在發生事件時向所有注冊的監聽器發送事件對象。
監聽器對象使用事件對象中的信息來確定它們對事件的響應
事件模型：
基於代理(授權)事件模型，事件處理是一個事件源授權到一個或者多個事件監聽器。其基本原理是：組件激發事件，事件監聽器監聽和處理事件，可以調用組件的add<EventType>Listener方法向組件注冊監聽器。把其加入到組件以後，如果組件激發了相應類型的事件，那麼定義在監聽器中的事件處理方法會被調用。
此模型主要由以三種對象為中心組成
事件源由它來激發產生事件
是產生或拋出事件的對象。
事件監聽器由它來處理事件
實現某個特定EventListener介面,此介面定義了一種或多種方法，事件源調用它們以響應該介面所處理的每一種特定事件類型。
事件具體的事件類型
事件類型封裝在以java.util.EventObject為根的類層次中。當事件發生時，事件記錄發生的一切事件，並從事件源傳播到監聽器對象
⑼ java中如何實現多按鍵同時按下的鍵盤監聽事件
1，為相應的控制項設置KeyListener()的監聽
2，實現介面中的方法
3，主要重寫keyPressed（）這個方法
4，書寫邏輯
5，見代碼
public void keyPressed(KeyEvent e) {
if(e.getKeyCode()==KeyEvent.VK_1&&e.getKeyCode()==KeyEvent.VK_2){
System.out.println("1,2鍵被點擊了。。。");
}
}ps，還可以自己寫一個數組記錄每個按鍵的狀態，根據狀態值進行邏輯處理。
⑽ java中的事件監聽是怎樣實現隨時監聽的，是通過線程嗎
java中的事件監聽不是通過線程實現的，它是通過一種注冊--通知機制實現的。在java的設計模式中，有一種模式叫：觀察者模式，和這個類似。