計算機專業(yè)外文翻譯---事件處理基礎(chǔ)

上傳人：奔*** IP屬地：河北更新時間：2024-03-01 格式：doc 頁數(shù)：19 大?。?98.00KB 人氣指數(shù)：12 舉報 版權(quán)申訴

已閱讀1頁，還剩18頁未讀，繼續(xù)免費閱讀

版權(quán)說明：本文檔由用戶提供并上傳，收益歸屬內(nèi)容提供方，若內(nèi)容存在侵權(quán)，請進行舉報或認領(lǐng)

文檔簡介

1、　　外文原文　　Basics of Event Handling　　出處:Thinking in java　　作者: Bruce Eckel 　　Any operating environment that supp

2、orts GUIs constantly monitors events such as keystrokes or mouse clicks. The operating environment reports these events to the programs that are running. Each program then decides what, if anything, to do in response to

3、these events. In languages like Visual Basic, the correspondence between events and code is obvious. One writes code for each specific event of interest and places the code in what is usually called an event procedure. F

4、or example, a Visual Basi　　On the other hand, if you use a language like raw C to do event-driven programming, you need to write the code that constantly checks the event queue for what the operating

5、 environment is reporting. This technique is obviously rather ugly, and, in any case, it is much more difficult to code. The advantage is that the events you can respond to are not as limited as in languages, like Visual

6、 Basic, that go to great lengths to hide the event queue from the programmer.　　The Java programming environment takes an approach somewhat between the Visual Basic approach and the raw C approach in

7、terms of power and, therefore, in resulting complexity. Within the limits of the events that the AWT knows about, you completely control how events are transmitted from the event sources (such as buttons or scrollbars) t

8、o event listeners. You can designate any object to be an event listener—in practice, you pick an object that can conveniently carry out the desired response to 　　Event sources have methods that allow

9、 you to register event listeners with them. When an event happens to the source, the source sends a notification of that event to all the listener objects that were registered for that event.　　As one

10、 would expect in an object-oriented language like Java, the information about the event is encapsulated in an event object. In Java, all event objects ultimately derive from the class java.util.EventObject. Of course, th

11、ere are subclasses for each event type, such as ActionEvent and WindowEvent.　　Different event sources can produce different kinds of events. For example, a button can send ActionEvent objects, wherea

12、s a window can send WindowEvent objects.　　To sum up, here's an overview of how event handling in the AWT works.　　A listener object is an instance of a class that implements a

13、 special interface called (naturally enough) a listener interface.　　An event source is an object that can register listener objects and send them event objects.　　The event source

14、 sends out event objects to all registered listeners when that event occurs.　　The listener objects will then use the information in the event object to determine their reaction to the event.

15、;　　You register the listener object with the source object by using lines of code that follow the model　　eventSourceObject.addEventListener(eventListenerObject);　　Here

16、 is an example:　　ActionListener listener = . . .;　　JButton button = new JButton("Ok");　　button.addActionListener(listener);　　N

17、ow the listener object is notified whenever an "action event" occurs in the button. For buttons, as you might expect, an action event is a button click.　　Code like the above requires that t

18、he class to which the listener object belongs implements the appropriate interface (which in this case is the ActionListener interface). As with all interfaces in Java, implementing an interface means supplying methods w

19、ith the right signatures. To implement the ActionListener interface, the listener class must have a method called actionPerformed that receives an ActionEvent object as a parameter.　　class MyListener

20、 implements ActionListener　　{　　. . .　　public void actionPerformed(ActionEvent event)　　{&l

21、t;/b>　　// reaction to button click goes here　　. . .　　}　　}<p&g

22、t;　　Whenever the user clicks the button, the JButton object creates an ActionEvent object and calls listener.actionPerformed(event), passing that event object. It is possible for multiple objects to be added as listeners

23、 to an event source such as a button. In that case, the button calls the actionPerformed methods of all listeners whenever the user clicks the button.　　Figure 8-1 shows the interaction between the ev

24、ent source, event listener, and event object.　　Figure 8-1. Event notification　　Example: Handling a Button Click　　As a way of getting comfortable with the eve

25、nt delegation model, let's work through all details needed for the simple example of responding to a button click. For this example, we will want　　A panel populated with three buttons; and</p&

26、gt;　　Three listener objects that are added as action listeners to the buttons.　　With this scenario, each time a user clicks on any of the buttons on the panel, the associated listener obje

27、ct then receives an ActionEvent that indicates a button click. In our sample program, the listener object will then change the background color of the panel.　　Before we can show you the program that

28、listens to button clicks, we first need to explain how to create buttons and how to add them to a panel. (For more on GUI elements, see Chapter 9.)　　You create a button by specifying a label string,

29、an icon, or both in the button constructor. Here are two examples:　　JButton yellowButton = new JButton("Yellow");　　JButton blueButton = new JButton(new ImageIcon("

30、blue-ball.gif"));　　Adding buttons to a panel occurs through a call to a method named (quite mnemonically) add. The add method takes as a parameter the specific component to be added to the conta

31、iner. For example,　　class ButtonPanel extends JPanel　　{　　public ButtonPanel()　　{<p&

32、gt;　　JButton yellowButton = new JButton("Yellow");　　JButton blueButton = new JButton("Blue");　　JButton redButton = new JButton("Red");&l

33、t;p>　　add(yellowButton);　　add(blueButton);　　add(redButton);　　}　　}　　Figure

34、8-2 shows the result.　　Figure 8-2. A panel filled with buttons　　Now that you know how to add buttons to a panel, you'll need to add code that lets the panel listen to these b

35、uttons. This requires classes that implement the ActionListener interface, which, as we just mentioned, has one method: actionPerformed, whose signature looks like this:　　public void actionPerformed(

36、ActionEvent event)　　NOTE: The ActionListener interface we used in the button example is not restricted to button clicks. It is used in many separate situations:　　When an item is

37、selected from a list box with a double click;　　When a menu item is selected;　　When the ENTER key is clicked in a text field;　　When a certain amount of time h

38、as elapsed for a Timer component.　　You will see more details in this chapter and the next.　　The way to use the ActionListener interface is the same in all situations: the actionP

39、erformed method (which is the only method in ActionListener) takes an object of type ActionEvent as a parameter. This event object gives you information about the event that happened.　　When a button

40、is clicked, then we want to set the background color of the panel to a particular color. We store the desired color in our listener class.　　class ColorAction implements ActionListener<

41、p>　　{　　public ColorAction(Color c)　　{　　backgroundColor = c;　　}&l

42、t;p>　　public void actionPerformed(ActionEvent event)　　{　　// set panel background color　　. . .&l

43、t;b>　　}　　private Color backgroundColor;　　}　　We then construct one object for each color and set the objects as the button lis

44、teners.　　ColorAction yellowAction = new ColorAction(Color.YELLOW);　　ColorAction blueAction = new ColorAction(Color.BLUE);　　ColorAction redAction = new ColorA

45、ction(Color.RED);　　yellowButton.addActionListener(yellowAction);　　blueButton.addActionListener(blueAction);　　redButton.addActionListener(redAction);

46、;　　For example, if a user clicks on the button marked "Yellow," then the actionPerformed method of the yellowAction object is called. Its backgroundColor instance field is set to Color.YELLOW, and it

47、 can now proceed to set the panel's background color.　　Just one issue remains. The ColorAction object doesn't have access to the panel variable. You can solve this problem in two ways. You ca

48、n store the panel in the ColorAction object and set it in the ColorAction constructor. Or, more conveniently, you can make ColorAction into an inner class of the ButtonPanel class. Its methods can then access the outer p

49、anel automatically. (For more information on inner classes, see Chapter 6.)　　We follow the latter approach. Here is how you place the ColorAction class inside the ButtonPanel class.<p&

50、gt;　　class ButtonPanel extends JPanel{ . . . private class ColorAction implements ActionListener{ . . . public void action

51、Performed(ActionEvent event) { setBackground(backgroundColor); // i.e., outer.setBackground(...)

52、0; } private Color backgroundColor; }}　　Look closely at the actionPerformed method. The ColorAction class doesn't have a setBackground method. But

53、the outer ButtonPanel class does. The methods are invoked on the ButtonPanel object that constructed the inner class objects. (Note again that outer is not a keyword in the Java programming language. We just use it as an

54、 intuitive symbol for the invisible outer class reference in the inner class object.)　　This situation is very common. Event listener objects usually need to carry out some action that affects other o

55、bjects. You can often strategically place the listener class inside the class whose state the listener should modify.　　Becoming Comfortable with Inner Classes　　Some people dislik

56、e inner classes because they feel that a proliferation of classes and objects makes their programs slower. Let's have a look at that claim. You don't need a new class for every user interface component. In our ex

57、ample, all three buttons share the same listener class. Of course, each of them has a separate listener object. But these objects aren't large. They each contain a color value and a reference to the panel. And the tr

58、aditional solution, with if . . . else statements, als　　We believe the time has come to get used to inner classes. We recommend that you use dedicated inner classes for event handlers rather than tur

59、ning existing classes into listeners. We think that even anonymous inner classes have their place.　　Here is a good example of how anonymous inner classes can actually simplify your code. If you look

60、at the code of Example 8-1, you will note that each button requires the same treatment:　　1.Construct the button with a label string.　　2. Add the button to the panel.&

61、lt;p>　　3.Construct an action listener with the appropriate color.　　4. Add that action listener.　　Let's implement a helper method to simplify these tasks:<p&

62、gt;　　void makeButton(String name, Color backgroundColor)　　{　　JButton button = new JButton(name);　　add(button);　　Color

63、Action action = new ColorAction(backgroundColor);　　button.addActionListener(action);　　}　　Then the ButtonPanel constructor simply becomes&l

64、t;/p>　　public ButtonPanel()　　{　　makeButton("yellow", Color.YELLOW);　　makeButton("blue", Color.BLUE);<

65、/p>　　makeButton("red", Color.RED);　　}　　Now you can make a further simplification. Note that the ColorAction class is only needed once:

66、in the makeButton method. Therefore, you can make it into an anonymous class:　　void makeButton(String name, final Color backgroundColor)　　{

67、;　　JButton button = new JButton(name);　　add(button);　　button.addActionListener(new　　ActionListener()　　{&l

68、t;p>　　public void actionPerformed(ActionEvent event)　　{　　setBackground(backgroundColor);　　}<

69、b>　　});　　}　　The action listener code has become quite a bit simpler. The actionPerformed method simply refers to the parameter variable background

70、Color.　　No explicit constructor is needed. As you saw in Chapter 6, the inner class mechanism automatically generates a constructor that stores all local final variables that are used in one of the m

71、ethods of the inner class.　　TIP: Anonymous inner classes can look confusing. But you can get used to deciphering them if you train your eyes to glaze over the routine code, like this:<

72、p>　　button.addActionListener(new　　ActionListener()　　{　　public void actionPerformed(ActionEvent event)　　{&

73、lt;/b>　　setBackground(backgroundColor);　　}　　});　　That is, the button action sets the background

74、 color. As long as the event handler consists of just a few statements, we think this can be quite readable, particularly if you don't worry about the inner class mechanics.　　TIP: JDK 1.4 introdu

75、ces a mechanism that lets you specify simple event listeners without programming inner classes. For example, suppose you have a button labeled Load whose event handler contains a single method call:

76、　frame.loadData();　　Of course, you can use an anonymous inner class:　　loadButton.addActionListener(new　　ActionListener()　　{<

77、/b>　　public void actionPerformed(ActionEvent event)　　{　　frame.loadData();　　}<p&g

78、t;　　});　　But the EventHandler class can create such a listener automatically, with the call　　EventHandler.create(ActionListener.class, frame, "loadData&qu

79、ot;)　　Of course, you still need to install the handler:　　loadButton.addActionListener((ActionListener)　　EventHandler.create(ActionListener.class, frame, &quo

80、t;loadData"));　　The cast is necessary because the create method returns an Object. Perhaps a future version of the JDK will make use of generic types to make this method even more convenient.<

81、;/p>　　If the event listener calls a method with a single parameter that is derived from the event handler, then you can use another form of the create method. For example, the call　　Eve

82、ntHandler.create(ActionListener.class, frame, "loadData", "source.text")　　is equivalent to　　new ActionListener()　　{<

83、;/p>　　public void actionPerformed(ActionEvent event)　　{　　frame.loadData(((JTextField) event.getSource()).getText());

84、;　　}　　}　　Note that the event handler turns the names of the properties source and text into method calls getSource and getText, using the JavaBeans c

85、onvention. (For more information on properties and JavaBeans components, please turn to Volume 2.)　　However, in practice, this situation is not all that common, and there is no mechanism for supplyin

86、g parameters that aren't derived from the event object.　　事件處理基礎(chǔ)　　任何支持GUI的操作環(huán)境都要不斷地監(jiān)視敲擊鍵盤或點擊鼠標這樣的事件。操作環(huán)境將這些事件報告給正在運行的應(yīng)用程序。如果有事件產(chǎn)生，每個應(yīng)用程序?qū)Q定如何對它們做出響應(yīng)。在Visual

87、 Basic這樣的語言中，事件與代碼之間的對應(yīng)是明確的。程序員對相關(guān)的特定事件編寫代碼，并將這些代碼放置在過程中，通常人們將他們稱為事件過程。例如，一個名為HelpButton的Visual Basic按鈕有一個與之相關(guān)的HelpButton_Click事件過程。這個過程中的代碼將在點擊按鈕后執(zhí)行。每個Visual Basic的GUI組件都響應(yīng)一個固定的事件集， Visual Basic組件響應(yīng)的事件集是不能改變的。

88、　　另一方面，如果使用象原始C這樣的語言進行事件驅(qū)動的程序設(shè)計，就需要編寫代碼來不斷地檢查事件隊列，以便查詢操作環(huán)境報告的內(nèi)容。。顯然，這種方式編寫的程序可讀性很差，而且在有些情況下，編碼的難度也非常大。它的好處在于響應(yīng)的事件不受限制，而不象Visual Basic這樣的語言，將事件隊列對程序員隱藏起來。　　JAVA程序設(shè)計環(huán)境折中了Visual Basic與原始C的事件處

89、理方式，因此，它既有著強大的功能，又具有一定的復(fù)雜性。在AWT所知的事件范圍內(nèi)，可以完全控制事件從事件源（例如按鈕或滾動條）到事件監(jiān)聽器的傳遞過程，并將任何對象指派給事件監(jiān)聽器。不過事實上，應(yīng)該選擇一個能夠便于響應(yīng)事件的對象。這種事件委托模型與Visual Basic那種預(yù)定義的監(jiān)聽器模型比較起來更加靈活，但卻需要編寫更多的代碼，整理起來也非常困難（至少熟悉它之前）。　　事件源有一些向其注冊事件

90、監(jiān)聽器的方法。當(dāng)某個事件源產(chǎn)生事件的時候，事件源會向所有事件監(jiān)聽器對象發(fā)送一個通告，當(dāng)然這些事件監(jiān)聽器事先已經(jīng)為事件注冊過了。　　像JAVA這樣的面向?qū)ο笳Z言，都將事件的相關(guān)信息封裝在一個事件對象中。在JAVA中，所有的事件對象都最終派生于java.util.EventObject類。當(dāng)然，每個事件類型還有子類，例如，ActionEvent和WindowEvent。<

91、;p>　　不同的事件源可以產(chǎn)生不同類型的事件。例如，按鈕可以發(fā)送一個ActionEvent對象，而窗口可以發(fā)送WindowEvent對象。　　綜上所述，下面給出了AWT事件處理機制的概要：　　·監(jiān)聽器對象是一個實現(xiàn)了特定接口的類的實例　　·事件源是一個能夠注冊監(jiān)聽器對象并發(fā)送事件對象的對

92、象　　·當(dāng)事件發(fā)生時，事件源將事件對象傳遞給所有注冊的監(jiān)聽器　　·監(jiān)聽器對象將利用事件對象中的信息決定如何對事件做出響應(yīng)　　可以利用下列代碼模型來為事件源對象注冊監(jiān)聽器對象：　　eventSourceObject.addEventListener(ev

93、entListenerObject);　　下面是一個例子：　　ActionListener listener=...;　　JButton button=new JButton("OK");　　button.addA

94、ctionListener(listener);　　現(xiàn)在，只要按鈕產(chǎn)生了一個“動作事件”，listener對象就會得到通告。對于按鈕來說，動作事件就是點擊按鈕。上面的代碼要求監(jiān)聽器對象所屬的類必須實現(xiàn)相應(yīng)的接口（在這個例子中是ActionListener接口）。與JAVA中所有的接口一樣，實現(xiàn)一個接口就意味著要用完全相同的簽名實現(xiàn)每個方法。為了實現(xiàn)ActionListener接口，監(jiān)聽器類必須有

95、一個被稱為ActionPerformed的方法，該方法接受一個ActionEvent對象參數(shù)。　　class MyListener implents ActionListener　　{　　public void actionPerformed(ActionEvent even

96、t)　　{　　//reaction to button click goes here　　}　　}　　只要用戶點擊按

97、鈕，JButton對象就會創(chuàng)建一個AtionEvent對象，然后調(diào)用listener.actionPormed(event)傳遞事件對象?？梢詫⒍鄠€監(jiān)聽器對象添加到一個像按鈕這樣的事件源中。這樣一來，只要用戶點擊按鈕，按鈕就會調(diào)用所有監(jiān)聽器的actionPerforned方法。　　圖8-1顯示了事件源、事件監(jiān)聽器和事件對象之間的協(xié)作關(guān)系。　　處理按鈕點擊

98、事件例子　　為了加深對事件委托模型的理解，下面以一個響應(yīng)按鈕點擊事件的簡單例子來說明所需要知道的所有細節(jié)。在這個例子中，我們想要：　　·在一個面板中放置三個按鈕　　·添加三個監(jiān)聽器對象用來作為按鈕的動作監(jiān)聽器　　在這個情況下，只要用戶點擊面板上的任何一

99、個按鈕，相關(guān)的監(jiān)聽器對象就會接受到一個ActionEvent對象，它表示有個按鈕被點擊了。在示例程序中，監(jiān)聽器對象將改變面板的背景顏色。　　在演示如何監(jiān)聽按鈕點擊事件之前，首先需要講解一下如何創(chuàng)建按鈕以及如何將它們添加到面板中。　　圖 8-1. 事件通告　　可以通過在按鈕構(gòu)造器中指定一個標簽字符串、一個圖標或兩項

100、都指定來創(chuàng)建一個按鈕。下面是兩個例子：　　JButton yellowButton=new JButton("Yellow");　　JButton blueButton=new JButton(new ImageIon("blue-ball.gif"));　　將按鈕添加到面

101、板中需要調(diào)用 add方法（十分容易記憶）。add方法的參數(shù)指定了將要放置到容器中的組件。例如，　　class ButtonPanel extends JPanel　　{　　public ButtonPanel()

102、{　　JButton yellowButton=new JButton("Yellow");　　JButton blueButton=new JButton("Blue");　　JButton redButton=new JButton("Re

103、d");　　add(yellowButton);　　add(blueButton);　　add(redButton);　　}　　}</p&

104、gt;　　圖8-2顯示了結(jié)果。　　圖8-2添上按鈕的面板　　至此，知道了如何將按鈕添加到面板上，接下來需要增加讓面板監(jiān)聽這些按鈕的代碼。這需要一個實現(xiàn)ActionListener接口的類，如前所述，它應(yīng)該包含一個actionPerformed方法，其簽名為：　　public void act

105、ionPerformed(ActionEvent event)　　注意:在按鈕例子中使用的ActionListener接口并不僅限于按鈕點擊事件。它可以應(yīng)用于很多情況：　　·當(dāng)采用鼠標雙擊的方式選擇了列表框中的一個選項時　　·當(dāng)選擇一個菜單項時　　&#

106、183;當(dāng)在文本域中敲擊ENTER時　　·對于一個Timer組件來說，當(dāng)?shù)竭_指定的時間間隔時　　在本章和下一章中，將會看到更加詳細的內(nèi)容。　　在各種情況下，使用ActionListener接口的方式都是一樣的：actionPerformed方法（ActionListener中的唯一方法）將接受一個Act

107、ionEvent類型的對象作為參數(shù)。這個事件對象包含了事件發(fā)生時的相關(guān)信息。　　當(dāng)按鈕被點擊時，我們希望將面板的背景顏色設(shè)置為指定的顏色。該顏色存儲在監(jiān)聽器類中。　　Class ColorAction implants ActionLostener　　{

108、　　public ColorAction(Color c)　　{　　backgroundColor=c;　　}　　public void actionPerformed(Act

109、ionEvent event)　　{　　// set panel background color　　private Color backgroundColor;　　}&l

110、t;p>　　}　　然后，為每種顏色構(gòu)造一個對象，并將這些對象設(shè)置為按鈕對象監(jiān)聽器。　　ColorAction yellowAction = new ColorAction(Color.YELLOW);　　ColorAction blueAction = new Colo

111、rAction(Color.BLUE);　　ColorAction redAction = new ColorAction(Color.RED);　　yellowButton.addActionListener(yellowAction);　　blueButton.addActionListener(blueAc

112、tion);　　redButton.addActionListener(redAction);　　例如，如果一個用戶在標有“Yellow”的按鈕上點擊了一下，那么yellowAction對象的actionPerformed方法就會被調(diào)用。這個對象的backgroundColor實例域設(shè)置為Color.YELLOW,現(xiàn)在就將面板的背景設(shè)置為黃色了。<

眾賞文庫> 全部分類> 畢業(yè)設(shè)計

溫馨提示

1. 本站所有資源如無特殊說明，都需要本地電腦安裝OFFICE2007和PDF閱讀器。圖紙軟件為CAD,CAXA,PROE,UG,SolidWorks等.壓縮文件請下載最新的WinRAR軟件解壓。
2. 本站的文檔不包含任何第三方提供的附件圖紙等，如果需要附件，請聯(lián)系上傳者。文件的所有權(quán)益歸上傳用戶所有。
3. 本站RAR壓縮包中若帶圖紙，網(wǎng)頁內(nèi)容里面會有圖紙預(yù)覽，若沒有圖紙預(yù)覽就沒有圖紙。
4. 未經(jīng)權(quán)益所有人同意不得將文件中的內(nèi)容挪作商業(yè)或盈利用途。
5. 眾賞文庫僅提供信息存儲空間，僅對用戶上傳內(nèi)容的表現(xiàn)方式做保護處理，對用戶上傳分享的文檔內(nèi)容本身不做任何修改或編輯，并不能對任何下載內(nèi)容負責(zé)。
6. 下載文件中如有侵權(quán)或不適當(dāng)內(nèi)容，請與我們聯(lián)系，我們立即糾正。
7. 本站不保證下載資源的準確性、安全性和完整性, 同時也不承擔(dān)用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。

計算機專業(yè)外文翻譯---事件處理基礎(chǔ)

文檔簡介

溫馨提示

最新文檔

評論

計算機專業(yè)外文翻譯---事件處理基礎(chǔ)

文檔簡介

溫馨提示

最新文檔

評論

免費下載