giáo trình Java By Example phần 3

Chia sẻ: Thái Duy Ái Ngọc | Ngày: | Loại File: PDF | Số trang:57

Thêm vào BST

Báo xấu

115
lượt xem 35
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

Tham khảo tài liệu 'giáo trình java by example phần 3', công nghệ thông tin, kỹ thuật lập trình phục vụ nhu cầu học tập, nghiên cứu và làm việc hiệu quả

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: giáo trình Java By Example phần 3

MenuBar menuBar = new MenuBar( ); As you can see, the MenuBar( ) constructor requires no arguments. After you've created the MenuBar object, you have to tell Java to associate the menu bar with the frame window. You do this by calling the window's setMenuBar( ) method: setMenuBar(menuBar); At this point, you have an empty menu bar associated with the window. In the next steps, you add menus to the menu bar. Adding Menus to a Menu Bar A menu bar is the horizontal area near the top of a window that contains the names of the menus contained in the menu bar. After creating and setting the MenuBar object, you have the menu bar, but it contains no menus. To add these menus, you first create objects of the Menu class for each menu you want in the menu bar, like this: Menu fileMenu = new Menu("File"); Menu editMenu = new Menu("Edit"); Menu optionMenu = new Menu("Options"); The Menu class's constructor takes a single argument, which is the string that'll appear as the menu's name on the menu bar. The example lines above create three menus for the menu bar. After creating the Menu objects, you have to add them to the menu bar, which you do by calling the MenuBar object's add( ) method, like this: menuBar.add(fileMenu); menuBar.add(editMenu); menuBar.add(optionMenu); After Java executes the above three lines, you have a menu bar with three menus, as shown in Figure 23.4. Note, however, that at this point the menus contain no commands. If you were to click on the menu http://www.ngohaianh.info
names, no pop-up menus would appear. Figure 23.4 : This window's menu bar contains three empty menus. Adding Menu Items to Menus You may have empty menus at this point, but you're about to remedy that problem. To add items to your menus, you first create objects of the MenuItem or CheckboxMenuItem classes for each menu item you need. To add items to the Options menus you made previously, you might use Java code something like this: MenuItem option1 = new MenuItem("Option 1"); MenuItem option2 = new MenuItem("Option 2"); MenuItem option3 = new MenuItem("Option 3"); The MenuItem constructor takes as its single argument the string that'll be displayed in the menu for this item. If you're thinking that, after you create the menu items, you must call the appropriate Menu object's add( ) method, you're be exactly right. Those lines might look like this: optionMenu.add(option1); optionMenu.add(option2); optionMenu.add(option3); Now, when you display the frame window sporting the menu bar you've just created, you'll see that the Options menu contains a number of selections from which the user can choose, as shown in Figure 23.5. Figure 23.5 : Now the Options menu contains menu items. TIP Sometimes, you may have several groups of related commands that you'd like to place under a single menu. You can separate these command groups by using menu separators, which appear as horizontal lines in a pop-up menu. To create a menu separator, just create a regular MenuItem object with a string of "-". That is, the string should contain a single hyphen. http://www.ngohaianh.info
Example: Using a Menu Bar in a Frame Window Now that you have this menu bar business mastered, it's time to put what you've learned to work. Listing 23.4 is an applet called MenuBarApplet. This applet displays a single button, which, when selected, displays a frame window with a menu bar. This menu bar contains a single menu with three items. The first two items are regular MenuItem objects. The third item is CheckboxMenuItem, which is a menu item that can display a check mark. Figure 23.6 shows MenuBarApplet with its frame window displayed and the Test menu visible. (Notice the menu separator above the checked item.) Figure 23.6 : This is MenuBarApplet's frame window and menu bar. Listing 23.4 MenuBarApplet.java: An Applet That Uses a Menu Bar. import java.awt.*; import java.applet.*; public class MenuBarApplet extends Applet { MenuBarFrame frame; Button button; public void init() { frame = new MenuBarFrame("MenuBar Window"); button = new Button("Show Window"); add(button); } http://www.ngohaianh.info
public boolean action(Event evt, Object arg) { boolean visible = frame.isShowing(); if (visible) { frame.hide(); button.setLabel("Show Window"); } else { frame.show(); button.setLabel("Hide Window"); } return true; } } class MenuBarFrame extends Frame { MenuBar menuBar; String str; http://www.ngohaianh.info
MenuBarFrame(String title) { super(title); menuBar = new MenuBar(); setMenuBar(menuBar); Menu menu = new Menu("Test"); menuBar.add(menu); MenuItem item = new MenuItem("Command 1"); menu.add(item); item = new MenuItem("Command 2"); menu.add(item); item = new MenuItem("-"); menu.add(item); CheckboxMenuItem checkItem = new CheckboxMenuItem("Check"); menu.add(checkItem); str = ""; Font font = new Font("TimesRoman", Font.BOLD, 20); http://www.ngohaianh.info
setFont(font); } public void paint(Graphics g) { resize(300, 250); g.drawString(str, 20, 100); } public boolean action(Event evt, Object arg) { if (evt.target instanceof MenuItem) { if (arg == "Command 1") str = "You selected Command 1"; else if (arg == "Command 2") str = "You selected Command 2"; else if (arg == "Check") str = "You selected the Check item"; repaint(); return true; http://www.ngohaianh.info
} else return false; } } Tell Java that the applet uses the classes in the awt package. Tell Java that the applet uses the classes in the applet package. Derive the MenuBarApplet class from Java's Applet class. Declare the custom frame-window and button objects. Override the init( ) method. Create the custom frame window. Create and add the button component. Override the action( ) method. Determine whether the window is visible. If the window is visible... Hide the window. Change the button's label to "Show Window." Else if the window is hidden... Show the window. Change the button's label to "Hide Window." Tell Java that the message was handled okay. Derive the MenuBarFrame class from Java's Frame class. Declare the class's menu bar and string objects. Define the class's constructor. Pass the title string on to the Frame class. Create and set the menu bar. Create and add the Test menu. Create and add two regular menu items. Create and add a menu separator. Create and add a checkmark menu item. Initialize the class's display string and font. Override the window's paint( ) method. Resize the window. Show the display string in the window. Override the action( ) method. if a menu item was selected... Respond to the selected menu. Repaint the window, so the new string is displayed. http://www.ngohaianh.info
Return true if the message was handled. Or else return false so Java knows the event is unhandled. NOTE To determine the state (checked or unchecked) of a CheckboxMenuItem object, you can call its getState( ) method. This method returns true if the item is checked and false if the item is unchecked. In addition, you can set the item's state by calling its setState( ) method. As you can see from MenuBarApplet's source code, you respond to menu-item selections in the same way you respond to other events in applets. This time, however, you have overridden two action( ) methods. The first is in the MenuBarApplet class and handles the applet's single button. The second overridden action( ) method, which is the one that handles the menu items, is in the MenuBarFrame class. Summary Although it's an ability you may not frequently take advantage of, Java applets can display windows. The Frame class makes this possible, by providing the functionality for frame windows, which can be sized, moved, used to display components, and much more. A frame window can, in fact, even have a full-featured menu bar, just like the menu bars you see in many Windows applications. Creating a menu bar, however, requires knowing how to create and manipulate MenuBar, Menu, MenuItem, and CheckboxMenuItem objects. Luckily, you learned about those classes in this chapter, so you're all ready to amaze the world with your Java frame windows. Review Questions 1. How do you create a frame window? 2. How do you display a frame window after you create it? 3. How can you determine whether a frame window is currently visible? 4. What's the difference between MenuItem and CheckboxMenuItem objects? 5. Which Java class must you extend to create a custom frame-window class? 6. How do you ensure that a custom frame-window class has properly initialized its superclass? 7. How do you draw text or graphics in a frame window? 8. What are the six steps that must be completed in order to add a menu bar to a frame window? 9. How do you add components, such as controls, to a frame window? 10. How do you respond to selected menu items? 11. How do you create a menu separator object? http://www.ngohaianh.info
Review Exercises 1. Write an applet that displays a frame window as soon as the applet runs. 2. Write an applet that displays a frame window containing a 2x2 grid of buttons. 3. Modify the applet you wrote in exercise 2 so that the frame window contains a menu bar with two menus. Each menu should have a single menu item. 4. Modify the MenuBarApplet so that the menu bar has an additional menu called View. This menu should contain a single checkmarked option called Window that determines whether a second frame window is visible on the screen. When the user selects the Window command, the command should be checkmarked and the second window should appear. When the user clicks this command a second time, the second window should disappear and the command should be unchecked. Figure 23.7 shows the resultant applet in action. (You can find the solution to this exercise in the CHAP23 folder of this book's CD-ROM.) Figure 23.7 : This is MenuFrameApplet running under Appletviewer. http://www.ngohaianh.info
Chapter 22 Panels and Layout Managers CONTENTS Panels q Example: Creating and Using Panels r Layout Managers q The FlowLayout Manager q Example: Creating a FlowLayout Manager r The GridLayout Manager q Creating a GridLayout Manager r The BorderLayout Manager q Creating a BorderLayout Manager r The CardLayout Manager q The CardLayout Manager Methods r Example: Creating a CardLayout Manager r The GridBagLayout Manager q Creating and Setting the GridBagLayout Manager r Creating and Setting a GridBagConstraints Object r Example: Using a GridBagLayout Manager in an Applet r Understanding the GridBagApplet Applet r Summary q Review Questions q Review Exercises q Up until the previous chapter, when you've added controls to your applets, you've let Java place those controls wherever it felt like it. The only way you could control positioning was by changing the size of the applet. Obviously, if you're going to produce attractive applets that are organized logically, you need some way to tell Java exactly where you want things placed. Java's layout managers were created for exactly this purpose. Working in conjunction with layout managers are components called panels, which enable you to organize other applet components. In this chapter, you learn about these two important layout components. http://www.ngohaianh.info
Panels A panel is a special type of container object that acts as a parent to other components that you want to organize in your applet. For example, you can add several panels to an applet, each with their own layout. By using panels in this way, you can create many different creative displays. Creating a panel is as easy as calling the Panel class's constructor, like this: Panel panel = new Panel(); As you can see, the Panel class's constructor requires no arguments. Once you create a panel, you add it to the applet in the normal way, by calling the add() method: add(panel); Example: Creating and Using Panels Using panels can be a little confusing at first, so an example is in order. Suppose you need to create an applet that displays four buttons, but you don't want Java to place the buttons one after the other in the display, which Java will do with its default layout. Instead, you want the buttons displayed in two rows of two. One way to accomplish this feat is to add two panels to the applet and then add two buttons to each panel. Listing 22.1 shows how this is done, whereas Figure 22.1 shows what the display looks like. Figure 22.1 : Using panels, you can more easily organize components in an applet. Listing 22.1 PanelApplet.java: Using Panels. import java.awt.*; import java.applet.*; public class PanelApplet extends Applet { Panel panel1, panel2; http://www.ngohaianh.info
Button button1, button2, button3, button4; public void init() { panel1 = new Panel(); panel2 = new Panel(); add(panel1); add(panel2); button1 = new Button("Button1"); button2 = new Button("Button2"); button3 = new Button("Button3"); button4 = new Button("Button4"); panel1.add(button1); panel1.add(button2); panel2.add(button3); panel2.add(button4); } } Tell Java that the applet uses the classes in the awt package. Tell Java that the applet uses the classes in the applet package. http://www.ngohaianh.info
Derive the PanelApplet class from Java's Applet class. Declare the panel and button objects. Override the init() method. Create the panels. Add the panels to the applet. Create the four buttons. Add the buttons to the panels. Notice how, when adding the panels to the applet, the program calls the PanelApplet class's add() method (which adds the panels to the applet's display). However, when adding the buttons, the program calls the panel objects' add() method (which adds the buttons to the panels). This is how you build a hierarchy of components into your applets. In this case, you've got a stack of components three high, with the applet's display on the bottom, the two panels on top of that, and the four buttons on top of the panels. As you create more sophisticated applets, this type of component stacking will be more common. Panels are kind of a "plain vanilla" container for organizing components in an applet. As you'll discover in the next section, you can combine panels with layout managers to create truly complex displays. Layout Managers Layout Managers are special objects that determine how elements of your applet are organized in the applet's display. When you create an applet, Java automatically creates and assigns a default layout manager. In many of the applets you've created so far in this book, it's the default layout manager that's determined where your controls appear. You can, however, create different types of layout managers in order to better control how your applets look. The layout managers you can use are listed below: q FlowLayout q GridLayout q BorderLayout q CardLayout q GridBagLayout Each of these layout managers is represented by a class of the same name. To create a layout manager for your applet, you first create an instance of the appropriate layout class and then call the setLayout() method to tell Java which layout object you want to use. In the following sections, you get a chance to see the various layout managers in action. The FlowLayout Manager In the previous section, I mentioned that, when you create an applet, Java assigns to it a default layout manager. It just so happens that this default manager is an object of the FlowLayout class. The FlowLayout manager places controls, in the order in which they're added, one after the other in horizontal rows. When the layout manager reaches the right border of the applet, it begins placing controls on the next row. In its default state, the FlowLayout manager centers controls on each row. However, you can set the alignment when you create the layout manager for your applet, like this: http://www.ngohaianh.info
FlowLayout layout = new FlowLayout(align, hor, ver); SetLayout(layout); The FlowLayout constructor takes three arguments, which are the alignment (FlowLayout.LEFT, FlowLayout.CENTER, or FlowLayout.RIGHT), the horizontal spacing between components, and the vertical spacing. Example: Creating a FlowLayout Manager Suppose that you want to arrange three buttons in an applet using a FlowLayout manager set to left alignment. Listing 22.2 shows how you'd create the manager and the buttons for the applet. Figure 22.2 shows the resultant control layout. Figures 22.3, and 22.4 show the center and right alignments for the same controls. Figure 22.2 : These buttons are left aligned by the FlowLayout manager. Figure 22.3 : These buttons are center aligned by the FlowLayout manager. Figure 22.4 : These buttons are right aligned by the FlowLayout manager. Listing 22.2 LST22_2.TXT: Creating a FlowLayout Manager. FlowLayout layout = new FlowLayout(FlowLayout.LEFT, 10, 10); setLayout(layout); button1 = new Button("Button1"); button2 = new Button("Button2"); button3 = new Button("Button3"); add(button1); add(button2); add(button3); http://www.ngohaianh.info
NOTE The FlowLayout() constructor shown in this chapter takes four arguments. However, you can actually construct a FlowLayout object with no arguments, FlowLayout(), or with a single argument for the alignment, FlowLayout(FlowLayout.LEFT). Many of Java's classes have multiple constructors. The GridLayout Manager Once you start creating more sophisticated applets, you'll quickly discover that the FlowLayout manager may not give you the control you need to create the kind of display you want for your applet. When you need more control over the placement of components, you can try out the GridLayout manager. Java's GridLayout manager organizes your applet's display into a rectangular grid, similar to the grid used in a spreadsheet. Java then places the components you create for the applet into each cell of the grid, working from left to right and top to bottom. You create a GridLayout manager like this: GridLayout layout = new GridLayout(rows, cols, hor, ver); SetLayout(layout); The constructor's four arguments are the number of rows in the grid, the number of columns, and the horizontal and vertical space between the grid cells. Creating a GridLayout Manager To test the GridLayout manager, suppose you want to place four buttons into a 2x2 grid, with no space between the buttons. Listing 22.3 shows how you'd create the manager and the buttons for the applet. Figure 22.5 shows the resultant control layout. Figure 22.6 shows the same layout manager, except created with horizontal and vertical spacing of 10, and Figure 22.7 shows the layout with a single row of four cells. Figure 22.5 : This GridLayout manager is set to two rows and two columns. Figure 22.6 : This is the same GridLayout manager with horizontal and vertical spacing. Figure 22.7 : This GridLayout manager has one row and four columns. Listing 22.3 LST22_3.TXT: Creating a GridLayout Manager. http://www.ngohaianh.info
GridLayout layout = new GridLayout(2, 2, 0, 0); setLayout(layout); button1 = new Button("Button1"); button2 = new Button("Button2"); button3 = new Button("Button3"); button4 = new Button("Button4"); add(button1); add(button2); add(button3); add(button4); The BorderLayout Manager You'll probably use the GridLayout manager most of the time, but there may be cases where you need to put together something a little more unusual. One layout you can try is provided by the BorderLayout manager, which enables you to position components using the directions north, south, east, west, and center. You create a BorderLayout manager object like this: BorderLayout layout = new BorderLayout(hor, ver); setLayout(layout); This constructor's two arguments are the horizontal and vertical spacing between the cells in the layout. After you create the BorderLayout object, you must add the components using a different version of the add() method: add(position, object); http://www.ngohaianh.info
Here, position is where to place the component and must be the string North, South, East, West, or Center. The second argument, object, is the component you want to add to the applet. Creating a BorderLayout Manager Suppose you have five buttons that you want to place in the five areas supported by a BorderLayout manager. First, you create and set the manager. Then, you create the five buttons and add them to the applet, using the special version of add() that includes the object's position as the first argument. Listing 22.4 shows how this is done. Figure 22.8 shows the resultant display, whereas Figure 22.9 shows the same applet with the BorderLayout manager with horizontal and vertical spacing. Figure 22.9 : This is the same applet with horizontal and vertical spacing. Figure 22.8 : This applet displays five buttons using a BorderLayout manager. Listing 22.4 LST22_4.TXT: Creating a BorderLayout Manager. BorderLayout layout = new BorderLayout(0, 0); setLayout(layout); button1 = new Button("Button1"); button2 = new Button("Button2"); button3 = new Button("Button3"); button4 = new Button("Button4"); button5 = new Button("Button5"); add("North", button1); add("South", button2); add("East", button3); add("West", button4); add("Center", button5); http://www.ngohaianh.info
The CardLayout Manager One of the most complex layout managers is CardLayout. Using this manager, you can create a stack of layouts not unlike a stack of cards and then flip from one layout to another. This type of display organization is not unlike Windows 95's tabbed dialogs, usually called property sheets. To create a layout with the CardLayout manager, you first create a parent panel to hold the "cards." Then, you create the CardLayout object and set it as the panel's layout manager. Finally, you add each "card" to the layout by creating the components and adding them to the panel. To create a CardLayout manager, call its constructor and then add it to the applet, like this: CardLayout cardLayout = new CardLayout(hor, ver); panel.setLayout(cardLayout); The constructor's two arguments are the horizontal and vertical spacing. The CardLayout Manager Methods Because the CardLayout manager enables you to switch between a stack of layouts, you need some way to tell the manager what to do. For this reason, the CardLayout manager has a number of public methods that you can call to specify which card is visible on the screen. Table 22.1 lists the most useful of these methods along with their descriptions. Table 22.1 CardLayout Manager Methods. Method Description first(Container parent) Displays the first card. last(Container parent) Displays the last card. next(Container parent) Displays the next card. previous(Container parent) Displays the previous card. show(Container parent, String name) Displays the specified card. Example: Creating a CardLayout Manager Putting the CardLayout manager to work is a lot easier if you always keep in mind the hierarchy of components. At the bottom of the stack is the applet's display area. On top of this stack is the component (usually a panel) that will hold the "cards." On top of the parent component is the CardLayout manager, which you can think of as a deck of cards. The cards in this deck are the components that you add to the panel. Listing 22.5 is an applet that demonstrates how all this works. The cards in this applet are the three buttons. When you run the applet, you see a single button in the display (Figure 22.10). Click the button http://www.ngohaianh.info
to switch to the next button in the stack. When you get to button three and click it, you end up back at button one. You can cycle through the buttons as often as you like. Figure 22.10 : Clicking the button switches the manager to a new card. Listing 22.5 CardApplet.java: Using a CardLayout Manager. import java.awt.*; import java.applet.*; public class CardApplet extends Applet { CardLayout cardLayout; Panel panel; Button button1, button2, button3; public void init() { panel = new Panel(); add(panel); cardLayout = new CardLayout(0, 0); panel.setLayout(cardLayout); button1 = new Button("Button1"); button2 = new Button("Button2"); http://www.ngohaianh.info
button3 = new Button("Button3"); panel.add("Button1", button1); panel.add("Button2", button2); panel.add("Button3", button3); } public boolean action(Event evt, Object arg) { cardLayout.next(panel); return true; } } Tell Java that the applet uses the classes in the awt package. Tell Java that the applet uses the classes in the applet package. Derive the CardApplet class from Java's Applet class. Declare the layout, panel, and button objects. Override the init() method. Create and add the parent panel. Create and set the layout. Create the buttons (which act as the cards). Add the buttons to the panel. Override the action() method. Switch to the next card (button). Tell Java that the event was handled okay. NOTE http://www.ngohaianh.info