❶ java 事件監聽
貌似沒問題啊，執行的也好好的。
你想說的一半距離是指什麼？
g.fillRect(x, y, 15, 15);
你在這里設置的長寬都是15
而你的speed=10;
那這樣每次只移動邊長的2/3有什麼好奇怪的？
你的x、y、speed
都是私有變數，如果沒有你注釋掉的方法介面，你是不能直接修改這三個變數的值的
你可以用setX(),setY(),setSpeed()分別來設置你的方塊的x坐標，y坐標，和每次按鍵的移動步長
你可以用getX(),getY()獲取你方塊當前的x坐標和y坐標，返回值是int類型
❷ 關於JAVA事件監聽
你這個問題是由於焦點(Focus)不正確引起的問題.
在窗口打開之後,如果焦點落在Frame上面,按鍵被Frame捕獲,提示輸出,如果焦點落在Button上面,剛按鍵被Button捕獲,當然就沒有輸出.
更改方法有如下建議:
1.this.setFocusable(true);加在構造函數最後,可以保證Frame可以響應鍵盤事件,但是按下按扭之後焦點轉移,鍵盤事件不再被Frame響應,因此需要按Tab鍵重新讓Frame得到焦點.(不推薦此方法,不知道按Tab鍵的用戶就慘了...)
2. 將鍵盤響應KeyListener分別注冊給所有的Button.
最後代碼如下:
import java.awt.*;
import java.awt.event.*;
public class ButtonTest extends Frame implements KeyListener,ActionListener{
private Button b1;
private Button b2;
public ButtonTest(int i,int j) {
addKeyListener(this);
setLayout(new FlowLayout(1));
b1=new Button("yellow");
b1.addActionListener(this);
b1.addKeyListener(this);
b2=new Button("blue");
b2.addActionListener(this);
b2.addKeyListener(this);
setSize(i, j);
add(b1);add(b2);
pack();
setVisible(true);
this.setFocusable(true);
}
//實現ActionListener介面方法
public void actionPerformed(ActionEvent a) {
if (a.getActionCommand().equals("yellow")) {
b1.setBackground(Color.red);
b2.requestFocus();//點擊button1時把事件焦點給b2
} else if (a.getActionCommand().equals("blue")) {
b2.setBackground(Color.BLUE);
}
}
//實現keylistener的3個方法
public void keyTyped(KeyEvent e){
System.out.println("KeyTyped"+" "+e);
}
public void keyPressed(KeyEvent e){
System.out.println("KeyPressed"+" "+e);
}
public void keyReleased(KeyEvent e){
System.out.println("KeyReleased"+" "+e);
}
public static void main(String[] args) {
ButtonTest my=new ButtonTest(300,300);
my.setSize(200,200);
}
}
❸ java中的事件監聽有什麼作用，怎麼用，用在什麼地方
主要用於 GUI界面 比如 對JButton進行監聽，只要加入監聽事件，就可寫你想發生的結果。如果以後從事web編程而不從事scoket編程，這幾乎沒有多大的用處。相對而言，j學習ava的事件監聽，很容易上手。
❹ java 事件監聽
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
import java.util.*;
public class Demo1 extends JFrame implements ActionListener {
int i=0;
ArrayList al = new ArrayList(2);
JPanel img=new JPanel();
public static void main(String[] args) {
// TODO 自動生成方法存根
Demo1 demo1 = new Demo1();
}
public Demo1() {
JLabel jl1=new JLabel(new ImageIcon("images/2.jpg"));
JLabel jl2=new JLabel(new ImageIcon("images/3.jpg"));
al.add(jl1);
al.add(jl2);
System.out.println(i);
JLabel jL = (JLabel) al.get(i);
img.add(jL, BorderLayout.CENTER);
this.add(img, BorderLayout.CENTER);
JButton jb1 = new JButton("上一張");
JButton jb2 = new JButton("下一張");
JPanel jp = new JPanel();
this.add(jp, BorderLayout.SOUTH);
jp.add(jb1, BorderLayout.EAST);
jp.add(jb2, BorderLayout.WEST);
jb1.addActionListener(this);
jb1.setActionCommand("上一張");
jb2.addActionListener(this);
jb2.setActionCommand("下一張");
this.setSize(560, 600);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
public void actionPerformed(ActionEvent arg0) {
// TODO 自動生成方法存根
if (arg0.getActionCommand().equals("下一張")) {
i++;
if(i>=al.size()){//翻到最後一張了，重新從第一張開始
i=0;
}
img.removeAll();
img.add((JLabel)al.get(i), BorderLayout.CENTER);
this.validate();//刷新組件
this.repaint();
}
if (arg0.getActionCommand().equals("上一張")) {
i--;
if(i<0){
i=al.size()-1;
}
img.removeAll();
img.add((JLabel)al.get(i), BorderLayout.CENTER);
this.validate();
this.repaint();
}
}
}
❺ java中的事件監聽是怎麼回事
不是通過線程實現的，它是通過一種注冊--通知機制實現的。在java的設計模式中，有一種模式叫：觀察者模式，和這個類似。舉個例子，本例子是一個簡單的監聽當數據發生變化時要做的操作。 1，我們先定義一個介面，可以讓多個監聽者實現 public interface IDataListen {public void update(Object event,Object msg);}2，實現一監聽者 public class DataListen implements IDataListen{ @Override public void update(Object event, Object arg) { // TODO Auto-generated method stub System.out.println("數據發生了變化"); }}3，被監聽者 public class DataManager{ private List<IDataListen> listenList = new ArrayList<>(); public void notifyListen(Object event,Object msg){ for(IDataListen dataListen : listenList){ dataListen.update(null, null); } } public void addListen(IDataListen dataListen){ listenList.add(dataListen); } public void updateData(Object msg){ this.notifyListen(null, msg); } public static void main(String[] args) { DataManager dataManager = new DataManager(); IDataListen dataListen1 = new DataListen(); ...
❻ java 事件監聽
比如你在有兩個鍵
JButton K = new JButton("K");
JButton T = new JButton("T");
且都已添加了監聽,那麼在介面實現方法中寫:
public void actionPerformed(ActionEvent ae)
{
//這樣K鍵和T鍵就有相同的作用了(如果只是實現相同的作用沒必要嵌套啊)
if(ae.getSouce==K || ae.getSouce== T)
{
//按鈕處理方法
}
}
❼ java事件監聽
你只要改下下面的就可以了：
JButton b,v;//在方法外面聲明JButton 對象（加上這一行）
public Test2() {
super("java實例");
b = new JButton("點擊");//把著兩行的JButton去掉就可以了，你之前是把它聲明在方法體內部的，在添加監聽器匹配對象是那個b拿不到，其他的都沒有什麼問題的
v = new JButton("確定");
getContentPane().add(b);
getContentPane().add(v);
setLayout(new FlowLayout());
b.addActionListener(this);
v.addActionListener(this);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(200, 200, 300, 300);
b.setBounds(0, 0, 30, 40);
v.setBounds(50, 50, 30, 40);
setVisible(true);
}
❽ java 事件監聽
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class LayoutTest extends JFrame implements ActionListener {
JButton jb1 = null;
JButton jb2 = null;
JButton jb3 = null;
JButton jb4 = null;
JButton jb5 = null;
public LayoutTest() {
this.setSize(200, 200);
this.setVisible(true);
this.setLayout(new BorderLayout());
jb1 = new JButton("up");
jb1.setActionCommand("up");
jb1.addActionListener(this);
jb2 = new JButton("down");
jb2.setActionCommand("down");
jb2.addActionListener(this);
jb3 = new JButton("left");
jb3.setActionCommand("left");
jb3.addActionListener(this);
jb4 = new JButton("right");
jb4.setActionCommand("right");
jb4.addActionListener(this);
jb5 = new JButton("center");
jb5.setActionCommand("center");
jb5.addActionListener(this);
// this.add(wp);
this.add("North", jb1);
this.add("South", jb2);
this.add("West", jb3);
this.add("East", jb4);
this.add("Center", jb5);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
LayoutTest lt = new LayoutTest();
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if (e.getActionCommand().equals("up")) {
System.out.println("You have clicked up!");
} else if (e.getActionCommand().equals("down")) {
System.out.println("You have clicked down!");
} else if (e.getActionCommand().equals("left")) {
System.out.println("You have clicked left!");
} else if (e.getActionCommand().equals("right")) {
System.out.println("You have clicked right");
} else if (e.getActionCommand().equals("center")) {
System.out.println("You have clicker center!");
}
}
}
❾ 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。