Java 的自定义事件

Question

定义自己的Event不难，但是要让你的Listener捕捉你的Event，可能有些费事，有兴趣你自己看看jdk源码，看看怎么做的

Answer 1

我想是不是类似于Windows的消息队列。大家说的详细点嘛。

Answer 2

这是从书上找的一个例子： 
import java.util.EventObject; 
import java.awt.Image; 
class SignatureEvent extends EventObject 
{ 
        protected Image signatureImage; 
        public SignatureEvent(Object source, Image signature) 
        { 
                super(source); 
                signatureImage = signature; 
        } 
        public Image getImage() 
        { 
                return signatureImage; 
        } 
}public interface SignatureEventListener 
{ 
        public void userSigned(SignatureEvent signature); 
         
} 
import java.awt.Canvas; 
import java.awt.*; 
import java.awt.event.*; 
import java.awt.image.*; 
class SigningSurface extends Canvas 
{ 
        protected int width, height; 
        protected int x, y, lastX, lastY; 
        protected Image offscreenImage = null; 
        protected Graphics offscreenG; 
        public SigningSurface() 
        { 
                enableEvents(AWTEvent.MOUSE_EVENT_MASK | 
                AWTEvent.MOUSE_MOTION_EVENT_MASK); 
        } 
         public void update(Graphics g) 
        { 
                paint(g); 
        } 
         public void paint(Graphics g) 
        { 
                if (offscreenImage == null) 
                { 
                        width  = getSize().width; 
                        height = getSize().height; 
                        offscreenImage = createImage(width, height); 
                        if (offscreenImage == null) 
                        { 
                                System.out.println("Error: Couldn't create offScreen."); 
                        } 
                        offscreenG = offscreenImage.getGraphics(); 
                } 
                g.drawImage(offscreenImage, 0, 0, this); 
        }          
        public void processMouseEvent(MouseEvent mouseEvent) 
        { 
                x = mouseEvent.getX(); 
                y = mouseEvent.getY(); 
                 
                switch (mouseEvent.getID()) 
                { 
                        case MouseEvent.MOUSE_PRESSED : 
                        { 
                                lastX = x; 
                                lastY = y; 
                                repaint(); 
                                break; 
                        } 
                        default: 
                            break; 
                } 
        }          
        protected void processMouseMotionEvent(MouseEvent mouseMotionEvent) 
        { 
                x = mouseMotionEvent.getX(); 
                y = mouseMotionEvent.getY(); 
                 
                switch (mouseMotionEvent.getID()) 
                { 
                        case MouseEvent.MOUSE_DRAGGED: 
                        { 
                                offscreenG.drawLine(x, y, lastX, lastY); 
                                lastX = x; 
                                lastY = y; 
                                repaint(); 
                                break; 
                        } 
                        default: 
                            break; 
                } 
        }          
        public Image getImage() 
        { 
                return offscreenImage; 
        }          
        public void wipeSignature() 
        { 
                wipeImage(offscreenImage, Color.white, this); 
                offscreenG.setColor(Color.black); 
                repaint(); 
        }      
        public static void wipeImage(Image im, Color col, ImageObserver observer) 
        { 
                Graphics g; 
                int width, height; 
                 
                g = im.getGraphics(); 
                width  = im.getWidth(observer); 
                height = im.getHeight(observer); 
                g.setColor(col); 
                g.fillRect(0, 0, width, height); 
        }       
} //endof class SigningSurface 

Answer 3

import java.awt.*; 
import java.awt.event.*; 
import java.util.*; 
public class SignMe extends Panel implements ActionListener 
{ 
        protected SigningSurface scribble; 
        protected Button eraseButton, acceptButton; 
        protected SignatureEventListener sigListener = null; 
         
        public SignMe() 
        { 
                Panel buttonsPanel, but1Panel, but2Panel; 
                setLayout(new BorderLayout()); 
                scribble = new SigningSurface(); 
                buttonsPanel = new Panel(); 
                but1Panel = new Panel(); 
                but2Panel = new Panel(); 
                 
                eraseButton = new Button("擦除"); 
                acceptButton = new Button("确定");           
                but1Panel.add(eraseButton); 
                but2Panel.add(acceptButton); 
                buttonsPanel.add(but1Panel); 
                buttonsPanel.add(but2Panel); 
                add(scribble, "Center"); 
                add(buttonsPanel, "South");             
                eraseButton.addActionListener(this); 
                acceptButton.addActionListener(this); 
        }   
        public void actionPerformed(ActionEvent buttonClick) 
        { 
                if (buttonClick.getSource() == eraseButton) 
                { 
                        scribble.wipeSignature(); 
                } 
                if (buttonClick.getSource() == acceptButton) 
                { 
                        System.out.println("user accepted signature!"); 
                        fireSignedEvent(); 
                } 
        } 
        public void addSignatureListener(SignatureEventListener listener) 
                    throws java.util.TooManyListenersException 
        { 
                if (sigListener != null) 
                { 
                        throw new TooManyListenersException("SignMe already has an event listener"); 
                } 
                sigListener = listener; 
        }   
        public void removeSignatureListener(SignatureEventListener listener) 
        { 
                if (sigListener == null) 
                { 
                        throw new IllegalArgumentException("Can't remove SignMe event"); 
                } 
                 
                if (sigListener != listener) 
                { 
                        throw new IllegalArgumentException("different from currently set!"); 
                } 
                sigListener = null; 
        }       
        protected void fireSignedEvent() 
        { 
                SignatureEvent event; 
                 
                if (sigListener != null) 
                { 
                        event = new SignatureEvent(this, scribble.getImage()); 
                        sigListener.userSigned(event); 
                } 
        } 
} //end of class SignMe 
import java.awt.Frame; 
import utilities.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.util.*; 
class SignMeClient extends Frame implements SignatureEventListener 
{ 
        protected SignMe sigWindow; 
         public static void main(String[] args) 
        { 
                new SignMeClient(); 
        }  
        public SignMeClient() 
        { 
                super("Sign Me Demo Window"); 
                sigWindow = new SignMe(); 
                 try 
                { 
                        sigWindow.addSignatureListener(this); 
                } 
                catch (TooManyListenersException ex) 
                { 
                        System.out.println("Could not register " + ex); 
                }              
                add(sigWindow, "Center"); 
                setSize(new Dimension(350, 250)); 
                setVisible(true); 
        }        
        public void userSigned(SignatureEvent signed) 
        { 
                Frame receivedSignWindow; 
                Graphics g; 
                Image sigImage; 
                int width, height;                  
                receivedSignWindow = new Frame("Received Signature"); 
                sigImage = signed.getImage(); 
                width = sigImage.getWidth(this); 
                height = sigImage.getHeight(this); 
                receivedSignWindow.setSize(new Dimension(width + 20, height + 20)); 
                receivedSignWindow.setVisible(true); 
                MiscKit.delay(300);               
                g = receivedSignWindow.getGraphics(); 
                int x = receivedSignWindow.getInsets().left; 
                int y = receivedSignWindow.getInsets().top; 
                g.drawImage(sigImage, x, y, receivedSignWindow); 
                MiscKit.delay(1000); 
                receivedSignWindow.setVisible(false); 
        }     
}

Answer 4

 楼上的兄弟所定义的事件本质还是 ActionEvent.
  比如说 在 Socket 编程重， 客户端收到一个消息 “Hello”， 然后要生成一个Hello事件，
然后由HelloEventListener来捕获， 然后来处理， 该怎么实现呢？
  再比如： 有一个小球 ， 它在画面上移动， 突然撞到了另一个小球， 这时要生成一个碰撞事件，
那么需要一个 碰撞事件Listener，
  这样需要的是一个比较低层的接口。谢谢大家支持！谢谢大家支持！谢谢大家支持！