AWT and Swing

Abstract Window Toolkit (AWT):

　　Introduced in Java 1.0 Provides classes and other tools for building programs that have a graphical user interface

　　The term “Abstract” refers to the AWT’s ability to run on multiple platforms.

　　Building a GUI involves creating “abstract” components such as buttons and windows, which are then mapped to “concrete” components for a specific platform.

Swing: Introduced in Java SE 1.2 Swing is more powerful and sophisticated than the AWT.

　　Swing is built around the existing AWT, so it helps to understand the AWT first.

　　Many Swing classes correspond to AWT classes.

For example, Swing’s JButton class corresponds to the AWT’s Button class.

Java Foundation Classes (JFC)

　　The Java Foundation Classes (JFC) are a graphical framework for building portable Java-based graphical user interfaces (GUIs).

　　JFC consists of:

　　　　Abstract Window Toolkit (AWT)

　　　　Swing

　　　　Java 2D

　　　　Together, they provide a consistent user interface for Java programs, regardless whether the underlying user interface system is Windows, Mac OS X or Linux.

Creating a Graphical User Interface

　　GUI programming in Java is based on three concepts:

　　　　Components: A component is an object that the user can see on the screen and—in most cases—interact with.

　　　　Containers: A container is a component that can hold other components.

　　　　Events: An event is an action triggered by the user, such as a key press or mouse click.

　　Designing a graphical user interface involves 1)creating components, 2)putting them into containers, 3)arranging for the program to respond to events.

Basic Principles:

　　Components are objects, so they’re created by invoking a constructor E.g., a button would be created by using a constructor belonging to the Button class.

　　Button b = new Button("Testing");

　　For a component to be visible, it must be added to a container, typically a frame

　　Actions. events and listeners: An event object is an object that the Java system creates at run-time to represent a user action,

　　e.g., a mouse click To detect when an event occurs, a special “listener” object can be attached to a component.

　　When the user performs an action that involves the component, a method belonging to the listener object will be called automatically.

Frames

　　In Java terminology, a frame is a window with a title and a border

　　It is a top level window, and may also have a menu bar.

　　Frame classes:

　　　　AWT: java.awt.Frame

　　　　Swing: javax.swing.JFrame

　　　　Frames play an important role in the AWT because a GUI program normally displays a frame when it’s executed.

-The Frame Class

　　Frames are created using one of the constructors in the JFrame class,

　　e.g.:

　　　　JFrame f = new JFrame("Title goes here");

　　　　JFrame methods:

　　　　 Set the size of the frame:

　　　　　　setSize(WIDTH, HEIGHT);

　　　　Set/get title:

　　　　　　setTitle(“Frame Title”);

　　　　　　String s=f.getTitle();

　　　　Set the size of the frame:

　　　　　　setSize(WIDTH, HEIGHT);

　　　　Set position of the frame:

　　　　　　setLocation(x,y);

　　　　Select closing options:

　　　　　　setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

　　　　Set the frame visibility:

　　　　　　setVisible(true);

　　　　　　setVisible(false);                       (The Frame object still exists; it can be made to reappear later by calling setVisible again.)

exa：

　　　　JFrame f = new Frame("Frame Test");  //new一个Frame

　　　　f.setTitle("A Simple Frame");

　　　　f.setSize(300, 200);

　　　　f.setLocation(100,100);

　　　　f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

　　　　f.setVisible(true);

-Frame size:

　　By default, a frame will be 0*0;

　　There is no good sizes, as users’ screens may have different resolutions We can get the screen size via the following steps: //大小为屏幕的四分之一

　　Toolkit kit=Toolkit.getDefaultToolkit();

　　Dimension screenSize=kit.getScreenSize();

　　int screenWidth=screenSize.width;

　　int screenHeight=screenSize.height;

　　int frameWidth=screenWidth/2;

　　int frameHeight=screenHeight/2;

　　this.setSize(frameWidth, frameHeight);

Adding Components to a Frame

　　java.awt.Component

　　A component is an object having a graphical representation that can be displayed on the screen and that can interact with the user.

　　Examples of components are the buttons, checkboxes, and scrollbars of a typical graphical user interface.

　　The superclass of all GUI elements

　　　　　　　　

　　Display something inside a frame

　　It can be done by drawing a string directly on the frame,

　　but that is not a good practice.

　　We normally create components, e.g., menu, button, …,

　　and then add them to a frame Component classes:

　　　　javax.swing.JComponent;

　　　　java.awt.Component;

　　public class MyComponent extends JComponent {

　　　　 public void paintComponent( Graphics g ){

　　　　　　//code for drawing

　　　　 }

　　　　}

　　myFrame.add(new MyComponent());

exa2

　　private Image image;

　　public class MyComponent extends JComponent {

　　　　public void paintComponent( Graphics g ){

　　　　image=new ImageIcon("aut.jpg").getImage();

　　　　g.drawImage(image, 0,0,null);

　　　　}

　　}

Button and Event handling

Create a button object (JButton):

　　JButton blue = new JButton(“Blue");

　　f.add(b);

　　The button has no effect now To make the button work, we need an event listener

Event Handling

　　General process:

　　When the user performs an action, Java creates an object containing information about the event.

　　An event source (e.g., a button) can register listener objects and send event objects to listeners Event objects will then be sent to listeners when events occurs

　　The listener objects will then use the information in the event objects to determine their reaction to the event.

　　　　　　

　　ActionListener interface:

　　We can create our own action listeners by implementing the ActionListener interface To implement the ActionListener interface, the class must have an actionPerfermed method (override)

　　

　　class MyListener implements ActionListener{

　　 ..…

　　public void actionPerformed(ActionEvent event){

　　　　 // reaction to button click

　　　　}

　　 }

Attach a listener object to each button:

　　MyListener listener=new MyListener();

　　button.addActionListener(listener);

sol1:

　　public ButtonTest() {

　　　　buttonPanel=new JPanel();

　　　　JButton blueButton=new JButton("blue");

　　　　JButton redButton=new JButton("red");

　　　　ActionListener blueAction= new ColorAction (Color.BLUE);

　　　　 ActionListener redAction= new ColorAction (Color.RED);

　　　　 blueButton.addActionListener(blueAction);

　　　　redButton.addActionListener(redAction);

　　　　 … }

　　public class ColorAction implements ActionListener{

　　　　private Color backgoundColor;

　　　　public ColorAction(Color c){

　　　　backgoundColor=c;

　　　　}

　　　　@Override

　　　　public void actionPerformed(ActionEvent e) {

　　　　　　 buttonPanel.setBackground(backgoundColor);

　　　　　　}

　　　　}

sol2:

　　public class ButtonTest2 extends JFrame implements ActionListener {

　　　　……

　　　　blueButton.addActionListener(this);

　　　　redButton.addActionListener(this);

　　　　……

　　 }

　　public void actionPerformed(ActionEvent e) {

　　　　Object source=e.getSource();

　　　　 if(source==blueButton){

　　　　　　buttonPanel.setBackground(Color.BLUE);

　　　　}

　　　　if(source==redButton){

　　　　　　buttonPanel.setBackground(Color.RED);

　　　　　　 }

　　　　}

Panel and Layout Management

-JPanel:

　　A generic lightweight container Components can be added to a panel

　　Then a panel can be added to a frame

　　Add components into a panel:

　　　　aPanel.add(component);

　　Clear a panel:

　　　　aPanel.removeAll();

　　Update a panel:

　　　　aPanel.revalidate();

　　　　aPanel.updateUI();

　　　　aPanel.repaint();

-Layout in a container:

　　You can set layout for a container to arrange multiple components

　　Every container has a default layout manager that determines the sizes and positions of components within the container

　　By using layout managers, containers can be resized gracefully.

　　

　　buttonPanel.add(blueButton);

　　buttonPanel.add(redButton);

　　frame.add(buttonPanel, BorderLayout.SOUTH);

GridLayout:

　　Arranges all components in rows and columns

　　In constructor of the grid layout object, you need to specify how many rows and columns you need:

　　Panel.setLayout(new GridLayout(3,4));

　　　　　　　　

Other GUI Components

JTextField:

　　Allow users to input text

　　You can add it to a panel or other container:

　　

　　JPanel panel=new JPanel();

　　JTextField textField=new JTextField(“Default Text”, 20);

　　panel.add(textField)

　　You can get the text in a TextField by using:

　　String text= textField.getText();

JLabel:

　　Hold text (display only)

　　Normally used to identify components

　　

　　JLabel label=new JLabel(“User name: ” , JLabel.Right);

　　The text in a label can be re-set:

　　label.setText(“password”);

JTextArea:

　　 Allow user input multiple lines of text

　　Users can use “Enter” to separate different lines

　　Each line ends with “\n”

　　JTextArea textArea=new JTextArea(8, 40);

JScollPane:

　　 A text area does not have scrollbars

　　You can place the text area inside a scroll pane

　　JTextArea textArea=new JTextArea(8, 40);

　　JScrollPane scrollPane=new JScrollPane(textArea);

JCheckBox:

　　A checkbox is a small box that the user can “check” by clicking with the mouse:

　　 Clicking on the box causes a check mark to appear:

　　 Clicking a second time removes the check mark from the box

　　JCheckBox sound= new JCheckBox(“Enable sounds”);

　　Use the setSelected method to turn a checkbox or/off:

　　sound.setSelected(true);

　　The isSelected method then returns the current state of a check box

　　ActionListener is needed to attach to a checkbox

　　……

　　bold = new JCheckBox("Bold");

　　bold.addActionListener(listener);

　　bold.setSelected(true);

　　buttonPanel.add(bold);

　　italic = new JCheckBox("Italic");

　　italic.addActionListener(listener);

　　……

　　ActionListener listener = new ActionListener() {

　　　　public void actionPerformed(ActionEvent event) {

　　　　 int mode = 0;

　　　　if (bold.isSelected())

　　　　mode += Font.BOLD;

　　　　 if (italic.isSelected())

　　　　 mode += Font.ITALIC;

　　　　 label.setFont(new Font("Serif", mode, FONTSIZE));

　　　　}

　　};

Radio Buttons:

　　 In many cases, we want the user to check one of several boxes:

　　When one box is checked, others are turned off automatically

　　In Swing, radio buttons can be constructed by following:

　　Construct a ButtonGroup object:

　　ButtonGroup group = new ButtonGroup();

　　Create JRadioButton objects, and add to the button group:

　　JRadioButton button = new JRadioButton(“left”, true);

　　group.add(button);

　　Attach with action listeners

　　button.addActionListener(listener);

Combo Boxes:

　　 If you want the users to choose from many options, then you need a combo box:

　　In Java 7, JComboBox is a generic class JComboBox<String> …

　　You can add items to a combo box via:

　　JComboBox<String> combo=new JComboBox();

　　combo.addItem(“China”);

　　you can get the selected item by using getSelectedItem(), but the item may have any type, and you need to cast the type.

　　Alternatively, the following method can give you selected item with the correct type:

　　combo.getItemAt(combo.getSelectedIndex());

　　Attach with action listeners