AWT 快速指南

---

---

图形用户界面

图形用户界面 (GUI) 通过一些图形组件提供用户交互。例如，我们底层的操作系统也通过窗口、框架、面板、按钮、文本字段、文本区域、列表框、组合框、标签、复选框等提供 GUI。这些都称为组件。使用这些组件，我们可以为应用程序创建交互式用户界面。

GUI 对用户触发的事件做出响应并提供结果。GUI 完全基于事件。例如，单击按钮、关闭窗口、打开窗口、在文本区域中输入内容等。这些活动称为事件。GUI 使最终用户更容易使用应用程序。它也使它们更有趣。

基本术语

基于 GUI 的应用程序示例

以下是一些基于 GUI 的应用程序示例。

• 自动柜员机 (ATM)

• 航空售票系统

• 火车站的信息亭

• 移动应用程序

• 导航系统

GUI 相对于 CUI 的优势

• GUI 提供图形图标进行交互，而 CUI（字符用户界面）提供简单的基于文本的界面。

• GUI 使应用程序更具娱乐性和趣味性，而 CUI 则没有。

• GUI 提供点击执行环境，而在 CUI 中，我们每次都必须为任务输入命令。

• 新用户可以通过视觉指示轻松地与图形用户界面交互，但在字符用户界面中则比较困难。

• GUI 提供了许多对文件系统和操作系统的控制，而在 CUI 中，您必须使用难以记住的命令。

• GUI 中的窗口概念允许用户同时查看、操作和控制多个应用程序，而在 CUI 中，用户一次只能控制一项任务。

• GUI 提供多任务环境，CUI 也提供，但 CUI 没有 GUI 提供的那么轻松。

• 使用 GUI 更容易控制和导航操作系统，这在命令用户界面中变得非常缓慢。GUI 可以轻松自定义。

环境设置

本节指导您如何在机器上下载和设置 Java。请按照以下步骤设置环境。

Java SE 可从以下链接免费获取 下载 Java。因此，您可以根据您的操作系统下载一个版本。

按照说明下载 Java 并运行.exe文件以在您的机器上安装 Java。在您的机器上安装 Java 后，您需要设置环境变量以指向正确的安装目录

为 Windows 2000/XP 设置路径

假设您已将 Java 安装在c:\Program Files\java\jdk目录中

• 右键单击“我的电脑”，然后选择“属性”。

• 在“高级”选项卡下单击“环境变量”按钮。

• 现在更改“Path”变量，使其还包含 Java 可执行文件的路径。例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将您的路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

为 Windows 95/98/ME 设置路径

假设您已将 Java 安装在c:\Program Files\java\jdk目录中

• 编辑“C:\autoexec.bat”文件，并在末尾添加以下行

  “SET PATH=%PATH%;C:\Program Files\java\jdk\bin”

为 Linux、UNIX、Solaris、FreeBSD 设置路径

环境变量 PATH 应设置为指向 Java 二进制文件已安装的位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。

例如，如果您使用bash作为您的 shell，则您将在“.bashrc”的末尾添加以下行：export PATH=/path/to/java:$PATH

流行的 Java 编辑器

要编写 Java 程序，您需要一个文本编辑器。市场上甚至还有更多更复杂的 IDE 可用。但目前，您可以考虑以下之一

• 记事本：在 Windows 机器上，您可以使用任何简单的文本编辑器，如记事本（本教程推荐）、TextPad。

• Netbeans：是一个开源且免费的 Java IDE，可以从 http://www.netbeans.org/index.html 下载。

• Eclipse：也是一个由 Eclipse 开源社区开发的 Java IDE，可以从 http://www.eclipse.org/ 下载。

AWT 控件

每个用户界面都考虑以下三个主要方面

• UI 元素：这些是用户最终看到并与其交互的核心视觉元素。GWT 提供了大量广泛使用且常见的元素，从基本到复杂，我们将在本教程中介绍。

• 布局：它们定义了 UI 元素如何在屏幕上组织，并为 GUI（图形用户界面）提供最终的外观和感觉。这部分将在布局章节中介绍。

• 行为：这些是用户与 UI 元素交互时发生的事件。这部分将在事件处理章节中介绍。

每个 AWT 控件都继承自 Component 类中的属性。

AWT Component 类

简介

类Component是 AWT 非菜单用户界面控件的抽象基类。Component 表示具有图形表示的对象。

类声明

以下是java.awt.Component类的声明

public abstract class Component
   extends Object
      implements ImageObserver, MenuContainer, Serializable

字段

以下是java.awt.Component类的字段

• static float BOTTOM_ALIGNMENT -- getAlignmentY 的易用性常量。

• static float CENTER_ALIGNMENT -- getAlignmentY 和 getAlignmentX 的易用性常量。

• static float LEFT_ALIGNMENT -- getAlignmentX 的易用性常量。

• static float RIGHT_ALIGNMENT -- getAlignmentX 的易用性常量。

• static float TOP_ALIGNMENT -- getAlignmentY() 的易用性常量。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

AWT 标签类

简介

标签是一个被动控件，因为它在用户访问时不会创建任何事件。标签控件是 Label 的对象。标签显示一行只读文本。但是，文本可以由应用程序程序员更改，但不能以任何方式由最终用户更改。

类声明

以下是 **java.awt.Label** 类的声明

public class Label
   extends Component
      implements Accessible

字段

以下是java.awt.Component类的字段

• **static int CENTER** -- 表示标签应居中。

• **static int LEFT** -- 表示标签应左对齐。

• **static int RIGHT** -- 表示标签应右对齐。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

标签示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showLabelDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showLabelDemo(){
      headerLabel.setText("Control in action: Label");      

      Label label = new Label();
      label.setText("Welcome to TutorialsPoint AWT Tutorial.");
      label.setAlignment(Label.CENTER);
      label.setBackground(Color.GRAY);
      label.setForeground(Color.WHITE);
      controlPanel.add(label);
   
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 按钮类

简介

按钮是一个控件组件，它有一个标签，并在按下时生成一个事件。当按下并释放按钮时，AWT 通过调用按钮上的 processEvent 方法向按钮发送一个 ActionEvent 实例。按钮的 processEvent 方法接收按钮的所有事件；它通过调用自己的 processActionEvent 方法传递操作事件。后一种方法将操作事件传递给任何已注册对该按钮生成的事件感兴趣的操作侦听器。

如果应用程序希望根据按钮的按下和释放执行某些操作，则应实现 ActionListener 并注册新的侦听器以接收来自此按钮的事件，方法是调用按钮的 addActionListener 方法。应用程序可以使用按钮的操作命令作为消息传递协议。

类声明

以下是java.awt.Button类的声明

public class Button
   extends Component
      implements Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

按钮示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showButtonDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showButtonDemo(){
      headerLabel.setText("Control in action: Button"); 

      Button okButton = new Button("OK");
      Button submitButton = new Button("Submit");
      Button cancelButton = new Button("Cancel");

      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Ok Button clicked.");
         }
      });

      submitButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Submit Button clicked.");
         }
      });

      cancelButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Cancel Button clicked.");
         }
      });

      controlPanel.add(okButton);
      controlPanel.add(submitButton);
      controlPanel.add(cancelButton);       

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 复选框类

简介

复选框控件用于打开（true）或关闭（false）选项。每个复选框都有一个标签，表示复选框的作用。可以通过单击复选框来更改其状态。

类声明

以下是java.awt.Checkbox类的声明

public class Checkbox
   extends Component
      implements ItemSelectable,Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

复选框示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showCheckBoxDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showCheckBoxDemo(){

      headerLabel.setText("Control in action: CheckBox"); 

      Checkbox chkApple = new Checkbox("Apple");
      Checkbox chkMango = new Checkbox("Mango");
      Checkbox chkPeer = new Checkbox("Peer");


      chkApple.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {             
            statusLabel.setText("Apple Checkbox: " 
            + (e.getStateChange()==1?"checked":"unchecked"));
         }
      });

      chkMango.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            statusLabel.setText("Mango Checkbox: " 
            + (e.getStateChange()==1?"checked":"unchecked"));
         }
      });

      chkPeer.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            statusLabel.setText("Peer Checkbox: " 
            + (e.getStateChange()==1?"checked":"unchecked"));
         }
      });

      controlPanel.add(chkApple);
      controlPanel.add(chkMango);
      controlPanel.add(chkPeer);       

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 复选框组类

简介

CheckboxGroup 类用于对复选框集进行分组。

类声明

以下是java.awt.CheckboxGroup类的声明

public class CheckboxGroup
   extends Object
      implements Serializable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

复选框组示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showCheckBoxGroupDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showCheckBoxGroupDemo(){
    
      headerLabel.setText("Control in action: CheckBoxGroup"); 

      CheckboxGroup fruitGroup = new CheckboxGroup();

      Checkbox chkApple = new Checkbox("Apple",fruitGroup,true);
      Checkbox chkMango = new Checkbox("Mango",fruitGroup,false);
      Checkbox chkPeer = new Checkbox("Peer",fruitGroup,false);

      statusLabel.setText("Apple Checkbox: checked");
      chkApple.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {             
            statusLabel.setText("Apple Checkbox: checked");
         }
      });

      chkMango.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            statusLabel.setText("Mango Checkbox: checked");
         }
      });

      chkPeer.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            statusLabel.setText("Peer Checkbox: checked");
         }
      });

      controlPanel.add(chkApple);
      controlPanel.add(chkMango);   
      controlPanel.add(chkPeer);       

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 列表类

简介

List 表示文本项列表。可以配置列表，以便用户可以选择一个或多个项目。

类声明

以下是java.awt.List类的声明

public class List
   extends Component
      implements ItemSelectable, Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

列表示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showListDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showListDemo(){                                       

      headerLabel.setText("Control in action: List"); 
      final List fruitList = new List(4,false);

      fruitList.add("Apple");
      fruitList.add("Grapes");
      fruitList.add("Mango");
      fruitList.add("Peer");

      final List vegetableList = new List(4,true);
   
      vegetableList.add("Lady Finger");
      vegetableList.add("Onion");
      vegetableList.add("Potato");
      vegetableList.add("Tomato");

      Button showButton = new Button("Show");

      showButton.addActionListener(new ActionListener() {

         public void actionPerformed(ActionEvent e) {     
            String data = "Fruits Selected: " 
               + fruitList.getItem(fruitList.getSelectedIndex());
            data += ", Vegetables selected: ";
            for(String vegetable:vegetableList.getSelectedItems()){
               data += vegetable + " ";
            }
            statusLabel.setText(data);
         }
      }); 

      controlPanel.add(fruitList);
      controlPanel.add(vegetableList);
      controlPanel.add(showButton);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 文本字段类

简介

textField 组件允许用户编辑单行文本。当用户在文本字段中键入一个键时，事件将发送到 TextField。键事件可能是键按下、键释放或键入。键事件传递给已注册的 KeyListener。如果在文本字段上启用了 ActionEvent，则按下回车键也可能会触发 ActionEvent。

类声明

以下是java.awt.TextField类的声明

public class TextField
   extends TextComponent

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.TextComponent

• java.awt.Component

• java.lang.Object

TextField 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showTextFieldDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showTextFieldDemo(){
      headerLabel.setText("Control in action: TextField"); 

      Label  namelabel= new Label("User ID: ", Label.RIGHT);
      Label  passwordLabel = new Label("Password: ", Label.CENTER);
      final TextField userText = new TextField(6);
      final TextField passwordText = new TextField(6);
      passwordText.setEchoChar('*');

      Button loginButton = new Button("Login");
   
      loginButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {     
            String data = "Username: " + userText.getText();
            data += ", Password: " + passwordText.getText();
            statusLabel.setText(data);        
         }
      }); 

      controlPanel.add(namelabel);
      controlPanel.add(userText);
      controlPanel.add(passwordLabel);       
      controlPanel.add(passwordText);
      controlPanel.add(loginButton);
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT TextArea 类

简介

AWT 中的 TextArea 控件为我们提供了多行编辑区域。用户可以在这里输入任意数量的文本。当文本区域中的文本大于可视区域时，会自动出现滚动条，帮助我们上下和左右滚动文本。

类声明

以下是 java.awt.TextArea 类的声明

public class TextArea
   extends TextComponent

字段

以下是 java.awt.TextArea 类的字段

• static int SCROLLBARS_BOTH -- 创建并显示垂直和水平滚动条。

• static int SCROLLBARS_HORIZONTAL_ONLY -- 仅创建并显示水平滚动条。

• static int SCROLLBARS_NONE -- 不为文本区域创建或显示任何滚动条。

• static int SCROLLBARS_VERTICAL_ONLY -- 仅创建并显示垂直滚动条。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.TextComponent

• java.awt.Component

• java.lang.Object

TextArea 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showTextAreaDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showTextAreaDemo(){
      headerLabel.setText("Control in action: TextArea"); 

      Label  commentlabel= new Label("Comments: ", Label.RIGHT);

      final TextArea commentTextArea = new TextArea("This is a AWT tutorial "
      +"to make GUI application in Java.",5,30);

      Button showButton = new Button("Show");

      showButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {     
            statusLabel.setText( commentTextArea.getText());        
         }
      }); 

      controlPanel.add(commentlabel);
      controlPanel.add(commentTextArea);        
      controlPanel.add(showButton);
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT Choice 类

简介

Choice 控件用于显示选项的弹出菜单。选定的选项显示在菜单顶部。

类声明

以下是 java.awt.Choice 类的声明

public class Choice
   extends Component
      implements ItemSelectable, Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

Choice 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showChoiceDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showChoiceDemo(){                                       

      headerLabel.setText("Control in action: Choice"); 
      final Choice fruitChoice = new Choice();

      fruitChoice.add("Apple");
      fruitChoice.add("Grapes");
      fruitChoice.add("Mango");
      fruitChoice.add("Peer");

      Button showButton = new Button("Show");

      showButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {     
            String data = "Fruit Selected: " 
            + fruitChoice.getItem(fruitChoice.getSelectedIndex());
            statusLabel.setText(data);
         }
      }); 

      controlPanel.add(fruitChoice);
      controlPanel.add(showButton);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT Canvas 类

简介

Canvas 控件表示一个矩形区域，应用程序可以在其中绘制内容或接收用户创建的输入。

类声明

以下是 java.awt.Canvas 类的声明

public class Canvas
   extends Component
      implements Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

Canvas 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showCanvasDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showCanvasDemo(){
      headerLabel.setText("Control in action: Canvas"); 

      controlPanel.add(new MyCanvas());
      mainFrame.setVisible(true);  
   } 

   class MyCanvas extends Canvas {

      public MyCanvas () {
         setBackground (Color.GRAY);
         setSize(300, 300);
      }

      public void paint (Graphics g) {
         Graphics2D g2;
         g2 = (Graphics2D) g;
         g2.drawString ("It is a custom canvas area", 70, 70);
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT Image 类

简介

Image 控件是所有表示图形图像的图像类的超类。

类声明

以下是 java.awt.Image 类的声明

public abstract class Image
   extends Object

字段

以下是 java.awt.Image 类的字段

• protected float accelerationPriority -- 加速此图像的优先级。

• static int SCALE_AREA_AVERAGING -- 使用区域平均图像缩放算法。

• static int SCALE_DEFAULT -- 使用默认的图像缩放算法。

• static int SCALE_FAST -- 选择一个图像缩放算法，该算法比缩放图像的平滑度更优先考虑缩放速度。

• static int SCALE_REPLICATE -- 使用 ReplicateScaleFilter 类中体现的图像缩放算法。

• static int SCALE_SMOOTH -- 选择一个图像缩放算法，该算法比缩放速度更优先考虑图像平滑度。

• static Object UndefinedProperty -- 每当获取未为特定图像定义的属性时，应返回 UndefinedProperty 对象。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

图像示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showImageDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showImageDemo(){
      headerLabel.setText("Control in action: Image"); 

      controlPanel.add(new ImageComponent("resources/java.jpg"));
      mainFrame.setVisible(true);  
   }
	
   class ImageComponent extends Component {

      BufferedImage img;

      public void paint(Graphics g) {
         g.drawImage(img, 0, 0, null);
      }

      public ImageComponent(String path) {
         try {
            img = ImageIO.read(new File(path));
         } catch (IOException e) {
            e.printStackTrace();
         }
      }

      public Dimension getPreferredSize() {
         if (img == null) {
            return new Dimension(100,100);
         } else {
            return new Dimension(img.getWidth(), img.getHeight());
         }
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 滚动条类

简介

滚动条控件表示一个滚动条组件，以便用户从值的范围内进行选择。

类声明

以下是java.awt.Scrollbar类的声明

public class Scrollbar
   extends Component
      implements Adjustable, Accessible

字段

以下是 java.awt.Image 类的字段

• static int HORIZONTAL --表示水平滚动条的常量。

• static int VERTICAL --表示垂直滚动条的常量。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

滚动条示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showScrollbarDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showScrollbarDemo(){                                       
      headerLabel.setText("Control in action: Scrollbar"); 

      final Scrollbar horizontalScroller = new Scrollbar(Scrollbar.HORIZONTAL);
      final Scrollbar verticalScroller = new Scrollbar();
      verticalScroller.setOrientation(Scrollbar.VERTICAL);
      horizontalScroller.setMaximum (100);
      horizontalScroller.setMinimum (1);
      verticalScroller.setMaximum (100);
      verticalScroller.setMinimum (1);

      horizontalScroller.addAdjustmentListener(new AdjustmentListener() {

         @Override
         public void adjustmentValueChanged(AdjustmentEvent e) {
            statusLabel.setText("Horozontal: "
               +horizontalScroller.getValue() 
               +" ,Vertical: "
               + verticalScroller.getValue());
            }
         });

      verticalScroller.addAdjustmentListener(new AdjustmentListener() {

            @Override
            public void adjustmentValueChanged(AdjustmentEvent e) {
               statusLabel.setText("Horozontal: "
               +horizontalScroller.getValue() 
               +" ,Vertical: "+ verticalScroller.getValue());
            }
         });

      controlPanel.add(horizontalScroller);
      controlPanel.add(verticalScroller);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 对话框类

简介

对话框控件表示一个顶级窗口，带有标题和边框，用于从用户那里获取某种形式的输入。

类声明

以下是java.awt.Dialog类的声明

public class Dialog
extends Window

字段

以下是 java.awt.Image 类的字段

• static Dialog.ModalityType DEFAULT_MODALITY_TYPE -- 模态对话框的默认模态类型。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Window

• java.awt.Component

• java.lang.Object

对话框示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showDialogDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showDialogDemo(){
      headerLabel.setText("Control in action: Dialog"); 
      Button showAboutDialogButton = new Button("Show About Dialog");
      showAboutDialogButton.addActionListener(new ActionListener() {
	     @Override
         public void actionPerformed(ActionEvent e) {
            AboutDialog aboutDialog = new AboutDialog(mainFrame);
            aboutDialog.setVisible(true);
         }
      });

      controlPanel.add(showAboutDialogButton);
      mainFrame.setVisible(true);  
   }

   class AboutDialog extends Dialog {
      public AboutDialog(Frame parent){
         super(parent, true);         
         setBackground(Color.gray);
         setLayout(new BorderLayout());
         Panel panel = new Panel();
         panel.add(new Button("Close"));
         add("South", panel);
         setSize(200,200);

         addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent windowEvent){
               dispose();
            }
         });
      }

      public boolean action(Event evt, Object arg){
         if(arg.equals("Close")){
            dispose();
            return true;
         }
         return false;
      }

      public void paint(Graphics g){
         g.setColor(Color.white);
         g.drawString("TutorialsPoint.Com", 25,70 );
         g.drawString("Version 1.0", 60, 90);      
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 文件对话框类

简介

文件对话框控件表示一个对话框窗口，用户可以在其中选择文件。

类声明

以下是java.awt.FileDialog类的声明

public class FileDialog
   extends Dialog

字段

以下是 java.awt.Image 类的字段

• static int LOAD -- 此常量值指示文件对话框窗口的目的是查找要从中读取的文件。

• static int SAVE -- 此常量值指示文件对话框窗口的目的是查找要写入的文件。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Dialog

• java.awt.Window

• java.awt.Component

• java.lang.Object

文件对话框示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showFileDialogDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showFileDialogDemo(){
      headerLabel.setText("Control in action: FileDialog"); 

      final FileDialog fileDialog = new FileDialog(mainFrame,"Select file");
      Button showFileDialogButton = new Button("Open File");
      showFileDialogButton.addActionListener(new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent e) {
            fileDialog.setVisible(true);
            statusLabel.setText("File Selected :" 
            + fileDialog.getDirectory() + fileDialog.getFile());
         }
      });

      controlPanel.add(showFileDialogButton);
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

事件处理

什么是事件？

对象状态的变化称为事件，即事件描述源的状态变化。事件是由于用户与图形用户界面组件交互而产生的。例如，单击按钮、移动鼠标、通过键盘输入字符、从列表中选择项目、滚动页面等活动都会导致事件发生。

事件的类型

事件可以大致分为两类

• 前台事件 - 需要用户直接交互的事件。它们是由于用户与图形用户界面中的图形组件交互而产生的。例如，单击按钮、移动鼠标、通过键盘输入字符、从列表中选择项目、滚动页面等。

• 后台事件 - 不需要最终用户交互的事件称为后台事件。操作系统中断、硬件或软件故障、计时器超时、操作完成都是后台事件的示例。

什么是事件处理？

事件处理是一种控制事件并决定事件发生时应该执行什么操作的机制。这种机制包含称为事件处理程序的代码，当事件发生时会执行该代码。Java 使用委托事件模型来处理事件。此模型定义了生成和处理事件的标准机制。让我们简要介绍一下此模型。

委托事件模型具有以下主要参与者：

• 源 - 源是发生事件的对象。源负责将其处理程序提供发生的事件信息。Java 为源对象提供了类。

• 监听器 - 也称为事件处理程序。监听器负责对事件做出响应。从 Java 实现的角度来看，监听器也是一个对象。监听器等待直到收到事件。一旦收到事件，监听器就会处理该事件，然后返回。

这种方法的好处是用户界面逻辑与生成事件的逻辑完全分离。用户界面元素能够将事件处理委托给单独的代码部分。在此模型中，需要将监听器注册到源对象，以便监听器可以接收事件通知。这是一种有效的事件处理方式，因为事件通知仅发送给希望接收它们的监听器。

事件处理涉及的步骤

• 用户单击按钮，并生成事件。

• 现在，相关事件类的对象会自动创建，并且有关源和事件的信息会填充到同一个对象中。

• 事件对象被转发到已注册的监听器类的 method 中。

• 现在 method 被执行并返回。

关于监听器需要记住的要点

• 为了设计监听器类，我们必须开发一些监听器接口。这些监听器接口预测了一些必须由监听器类实现的公共抽象回调方法。

• 如果不实现任何预定义的接口，则您的类不能充当源对象的监听器类。

回调方法

这些方法由 API 提供者提供，由应用程序程序员定义，并由应用程序开发人员调用。这里，回调方法表示事件方法。响应事件，Java JRE 将触发回调方法。所有此类回调方法都在监听器接口中提供。

如果某个组件希望某个监听器侦听其事件，则源必须将其自身注册到监听器。

事件处理示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtControlDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtControlDemo {

   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtControlDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtControlDemo  awtControlDemo = new AwtControlDemo();
      awtControlDemo.showEventDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showEventDemo(){
      headerLabel.setText("Control in action: Button"); 

      Button okButton = new Button("OK");
      Button submitButton = new Button("Submit");
      Button cancelButton = new Button("Cancel");

      okButton.setActionCommand("OK");
      submitButton.setActionCommand("Submit");
      cancelButton.setActionCommand("Cancel");

      okButton.addActionListener(new ButtonClickListener()); 
      submitButton.addActionListener(new ButtonClickListener()); 
      cancelButton.addActionListener(new ButtonClickListener()); 

      controlPanel.add(okButton);
      controlPanel.add(submitButton);
      controlPanel.add(cancelButton);       

      mainFrame.setVisible(true);  
   }

   private class ButtonClickListener implements ActionListener{
      public void actionPerformed(ActionEvent e) {
         String command = e.getActionCommand();  
         if( command.equals( "OK" ))  {
            statusLabel.setText("Ok Button clicked.");
         }
         else if( command.equals( "Submit" ) )  {
            statusLabel.setText("Submit Button clicked."); 
         }
         else  {
            statusLabel.setText("Cancel Button clicked.");
         }  	
      }		
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtControlDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtControlDemo

验证以下输出

AWT 事件类

事件类表示事件。Java 为我们提供了各种事件类，但我们将讨论那些更常用的类。

EventObject 类

它是所有事件状态对象都应从中派生的根类。所有事件都使用对对象的引用（即源）进行构造，该对象在逻辑上被认为是事件最初发生的对象。此类在 java.util 包中定义。

类声明

以下是java.util.EventObject 类的声明

public class EventObject
   extends Object
      implements Serializable

字段

以下是java.util.EventObject 类的字段

• protected Object source -- 事件最初发生的对象。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

AWT 事件类

以下是常用事件类的列表。

AWT AWTEvent 类

它是所有 AWT 事件的根事件类。此类及其子类取代了原始的 java.awt.Event 类。此类在 java.awt 包中定义。此类具有名为 getID() 的方法，可用于确定事件的类型。

类声明

以下是java.awt.AWTEvent 类的声明

public class AWTEvent
   extends EventObject

字段

以下是java.awt.AWTEvent 类的字段

• static int ACTION_FIRST -- 用于操作事件的 id 范围中的第一个数字。

• static long ACTION_EVENT_MASK -- 用于选择操作事件的事件掩码。

• static long ADJUSTMENT_EVENT_MASK -- 用于选择调整事件的事件掩码。

• static long COMPONENT_EVENT_MASK -- 用于选择组件事件的事件掩码。

• protected boolean consumed -- 控制源处理完事件后是否将其发送回对等方 - false 表示将其发送到对等方；true 表示不发送。

• static long CONTAINER_EVENT_MASK -- 用于选择容器事件的事件掩码。

• static long FOCUS_EVENT_MASK -- 用于选择焦点事件的事件掩码。

• static long HIERARCHY_BOUNDS_EVENT_MASK -- 用于选择层次边界事件的事件掩码。

• static long HIERARCHY_EVENT_MASK -- 用于选择层次事件的事件掩码。

• protected int id -- 事件的 id。

• static long INPUT_METHOD_EVENT_MASK -- 用于选择输入方法事件的事件掩码。

• static long INVOCATION_EVENT_MASK -- 用于选择调用事件的事件掩码。

• static long ITEM_EVENT_MASK -- 用于选择项目事件的事件掩码。

• static long KEY_EVENT_MASK -- 用于选择键盘事件的事件掩码。

• static long MOUSE_EVENT_MASK -- 用于选择鼠标事件的事件掩码。

• static long MOUSE_MOTION_EVENT_MASK -- 用于选择鼠标移动事件的事件掩码。

• static long MOUSE_WHEEL_EVENT_MASK -- 用于选择鼠标滚轮事件的事件掩码。

• static long PAINT_EVENT_MASK -- 用于选择绘制事件的事件掩码。

• static int RESERVED_ID_MAX -- 保留的 AWT 事件 ID 的最大值。

• static long TEXT_EVENT_MASK -- 用于选择文本事件的事件掩码。

• static long WINDOW_EVENT_MASK -- 用于选择窗口事件的事件掩码。

• static long WINDOW_FOCUS_EVENT_MASK -- 用于选择窗口焦点事件的事件掩码。

• static long WINDOW_STATE_EVENT_MASK -- 用于选择窗口状态事件的事件掩码。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.util.EventObject

• java.lang.Object

AWT ActionEvent 类

此类在 java.awt.event 包中定义。当单击按钮或双击列表项时，将生成 ActionEvent。

类声明

以下是java.awt.event.ActionEvent 类的声明

public class ActionEvent
   extends AWTEvent

字段

以下是java.awt.event.ActionEvent 类的字段

• static int ACTION_FIRST -- 用于操作事件的 id 范围中的第一个数字。

• static int ACTION_LAST -- 用于操作事件的 id 范围中的最后一个数字。

• static int ACTION_PERFORMED -- 此事件 id 表示发生了有意义的操作。

• static int ALT_MASK -- Alt 键修饰符。

• static int CTRL_MASK -- Ctrl 键修饰符。

• static int META_MASK -- Meta 键修饰符。

• static int SHIFT_MASK -- Shift 键修饰符。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT InputEvent 类

InputEvent 类是所有组件级输入事件的根事件类。在输入事件以其默认方式由其来源正常处理之前，会将其传递给侦听器。这允许侦听器和组件子类“使用”事件，以便源不会以其默认方式处理它们。例如，使用 Button 组件上的 mousePressed 事件将阻止 Button 被激活。

类声明

以下是java.awt.event.InputEvent 类的声明

public abstract class InputEvent
   extends ComponentEvent

字段

以下是java.awt.event.InputEvent 类的字段

• static int ALT_DOWN_MASK -- Alt 键扩展修饰符常量。

• static int ALT_GRAPH_DOWN_MASK -- AltGraph 键扩展修饰符常量。

• static int ALT_GRAPH_MASK -- AltGraph 键修饰符常量。

• static int ALT_MASK -- Alt 键修饰符常量。

• static int BUTTON1_DOWN_MASK -- 鼠标按钮 1 扩展修饰符常量。

• static int BUTTON1_MASK -- 鼠标按钮 1 修饰符常量。

• static int BUTTON2_DOWN_MASK -- 鼠标按钮 2 扩展修饰符常量。

• static int BUTTON2_MASK -- 鼠标按钮 2 修饰符常量。

• static int BUTTON3_DOWN_MASK -- 鼠标按钮 3 扩展修饰符常量。

• static int BUTTON3_MASK -- 鼠标按钮 3 修饰符常量。

• static int CTRL_DOWN_MASK -- Ctrl 键扩展修饰符常量。

• static int CTRL_MASK -- Ctrl 键修饰符常量。

• static int META_DOWN_MASK -- Meta 键扩展修饰符常量。

• static int META_MASK -- Meta 键修饰符常量。

• static int SHIFT_DOWN_MASK -- Shift 键扩展修饰符常量。

• static int SHIFT_MASK -- Shift 键修饰符常量。

类方法

继承的方法

此类继承自以下类的方法

• java.awt.event.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT KeyEvent 类

在输入字符时会生成键盘事件。键盘事件有三种类型，用整数常量表示。这些键盘事件如下：

• KEY_PRESSED

• KEY_RELASED

• KEY_TYPED

类声明

以下是java.awt.event.KeyEvent类的声明

public class KeyEvent
   extends InputEvent

字段

以下是java.awt.InputEvent类的字段

• static char CHAR_UNDEFINED --对于不映射到有效 Unicode 字符的 KEY_PRESSED 和 KEY_RELEASED 事件，使用此值作为 keyChar 值。

• static int KEY_FIRST --键盘事件使用的 ID 范围内的第一个数字。

• static int KEY_LAST --键盘事件使用的 ID 范围内的最后一个数字。

• static int KEY_LOCATION_LEFT --一个常量，指示按下或释放的键位于左侧键位置（此键可能有多个位置）。

• static int KEY_LOCATION_NUMPAD --一个常量，指示键盘事件源自数字键盘或与数字键盘相对应的虚拟键。

• static int KEY_LOCATION_RIGHT --一个常量，指示按下或释放的键位于右侧键位置（此键可能有多个位置）。

• static int KEY_LOCATION_STANDARD --一个常量，指示按下或释放的键不区分键的左侧或右侧版本，并且不是源自数字键盘（或不是源自与数字键盘相对应的虚拟键）。

• static int KEY_LOCATION_UNKNOWN --一个常量，指示 keyLocation 不确定或不相关。

• static int KEY_PRESSED --“按键按下”事件。

• static int KEY_RELEASED --“按键释放”事件。

• static int KEY_TYPED --“按键输入”事件。

static int VK_0 --VK_0 到 VK_9 与 ASCII '0' 到 '9' 相同 (0x30 - 0x39)

• static int VK_1

• static int VK_2

• static int VK_3

• static int VK_4

• static int VK_5

• static int VK_6

• static int VK_7

• static int VK_8

• static int VK_9

• static int VK_A --VK_A 到 VK_Z 与 ASCII 'A' 到 'Z' 相同 (0x41 - 0x5A)

• static int VK_ACCEPT --接受或提交功能键的常量。

• static int VK_ADD

• static int VK_AGAIN

• static int VK_ALL_CANDIDATES --所有候选项功能键的常量。

• static int VK_ALPHANUMERIC --字母数字功能键的常量。

• static int VK_ALT

• static int VK_ALT_GRAPH --AltGraph 功能键的常量。

• static int VK_AMPERSAND

• static int VK_ASTERISK

• static int VK_AT --“@”键的常量。

• static int VK_B

• static int VK_BACK_QUOTE

• static int VK_BACK_SLASH --反斜杠键“\”的常量。

• static int VK_BACK_SPACE

• static int VK_BEGIN --开始键的常量。

• static int VK_BRACELEFT

• static int VK_BRACERIGHT

• static int VK_C

• static int VK_CANCEL

• static int VK_CAPS_LOCK

• static int VK_CIRCUMFLEX --“^”键的常量。

• static int VK_CLEAR

• static int VK_CLOSE_BRACKET --右方括号键“]”的常量。

• static int VK_CODE_INPUT --代码输入功能键的常量。

• static int VK_COLON --“:”键的常量。

• static int VK_COMMA --逗号键“,”的常量。

• static int VK_COMPOSE --组合功能键的常量。

• static int VK_CONTEXT_MENU --Microsoft Windows 上下文菜单键的常量。

• static int VK_CONTROL

• static int VK_CONVERT --转换功能键的常量。

• static int VK_COPY

• static int VK_CUT

• static int VK_D

• static int VK_DEAD_ABOVEDOT

• static int VK_DEAD_ABOVERING

• static int VK_DEAD_ACUTE

• static int VK_DEAD_BREVE

• static int VK_DEAD_CARON

• static int VK_DEAD_CEDILLA

• static int VK_DEAD_CIRCUMFLEX

• static int VK_DEAD_DIAERESIS

• static int VK_DEAD_DOUBLEACUTE

• static int VK_DEAD_GRAVE

• static int VK_DEAD_IOTA

• static int VK_DEAD_MACRON

• static int VK_DEAD_OGONEK

• static int VK_DEAD_SEMIVOICED_SOUND

• static int VK_DEAD_TILDE

• static int VK_DEAD_VOICED_SOUND

• static int VK_DECIMAL

• static int VK_DELETE

• static int VK_DIVIDE

• static int VK_DOLLAR --“$”键的常量。

• static int VK_DOWN --非数字键盘下方向键的常量。

• static int VK_E

• static int VK_END

• static int VK_ENTER

• static int VK_EQUALS --等号键“=”的常量。

• static int VK_ESCAPE

• static int VK_EURO_SIGN --欧元货币符号键的常量。

• static int VK_EXCLAMATION_MARK --“！”键的常量。

• static int VK_F

• static int VK_F1 --F1 功能键的常量。

• static int VK_F10 --F10 功能键的常量。

• static int VK_F11 --F11 功能键的常量。

• static int VK_F12 --F12 功能键的常量。

• static int VK_F13 --F13 功能键的常量。

• static int VK_F14 --F14 功能键的常量。

• static int VK_F15 --F15 功能键的常量。

• static int VK_F16 --F16 功能键的常量。

• static int VK_F17 --F17 功能键的常量。

• static int VK_F18 --F18 功能键的常量。

• static int VK_F19 --F19 功能键的常量。

• static int VK_F2 --F2 功能键的常量。

• static int VK_F20 --F20 功能键的常量。

• static int VK_F21 --F21 功能键的常量。

• static int VK_F22 --F22 功能键的常量。

• static int VK_F23 --F23 功能键的常量。

• static int VK_F24 --F24 功能键的常量。

• static int VK_F3 --F3 功能键的常量。

• static int VK_F4 --F4 功能键的常量。

• static int VK_F5 --F5 功能键的常量。

• static int VK_F6 --F6 功能键的常量。

• static int VK_F7 --F7 功能键的常量。

• static int VK_F8 --F8 功能键的常量。

• static int VK_F9 --F9 功能键的常量。

• static int VK_FINAL

• static int VK_FIND

• static int VK_FULL_WIDTH --全角字符功能键的常量。

• static int VK_G

• static int VK_GREATER

• static int VK_H

• static int VK_HALF_WIDTH --半角字符功能键的常量。

• static int VK_HELP

• static int VK_HIRAGANA --平假名功能键的常量。

• static int VK_HOME

• static int VK_I

• static int VK_INPUT_METHOD_ON_OFF --输入法开关键的常量。

• static int VK_INSERT

• static int VK_INVERTED_EXCLAMATION_MARK --倒置感叹号键的常量。

• static int VK_J

• static int VK_JAPANESE_HIRAGANA --日语平假名功能键的常量。

• static int VK_JAPANESE_KATAKANA --日语片假名功能键的常量。

• static int VK_JAPANESE_ROMAN --日语罗马字功能键的常量。

• static int VK_K

• static int VK_KANA

• static int VK_KANA_LOCK --锁定假名功能键的常量。

• static int VK_KANJI

• static int VK_KATAKANA --片假名功能键的常量。

• static int VK_KP_DOWN --数字键盘下方向键的常量。

• static int VK_KP_LEFT --数字键盘左方向键的常量。

• static int VK_KP_RIGHT --数字键盘右方向键的常量。

• static int VK_KP_UP --数字键盘上方向键的常量。

• static int VK_L

• static int VK_LEFT --非数字键盘左方向键的常量。

• static int VK_LEFT_PARENTHESIS --“（”键的常量。

• static int VK_LESS

• static int VK_M

• static int VK_META

• static int VK_MINUS --减号键“ - ”的常量。

• static int VK_MODECHANGE

• static int VK_MULTIPLY

• static int VK_N

• static int VK_NONCONVERT --不要转换功能键的常量。

• static int VK_NUM_LOCK

• static int VK_NUMBER_SIGN --“#”键的常量。

• static int VK_NUMPAD0

• static int VK_NUMPAD1

• static int VK_NUMPAD2

• static int VK_NUMPAD3

• static int VK_NUMPAD4

• static int VK_NUMPAD5

• static int VK_NUMPAD6

• static int VK_NUMPAD7

• static int VK_NUMPAD8

• static int VK_NUMPAD9

• static int VK_O

• static int VK_OPEN_BRACKET --左方括号键“ [ ”的常量。

• static int VK_P

• static int VK_PAGE_DOWN

• static int VK_PAGE_UP

• static int VK_PASTE

• static int VK_PAUSE

• static int VK_PERIOD --句号键“.”的常量。

• static int VK_PLUS --加号键“+”的常量。

• static int VK_PREVIOUS_CANDIDATE --上一个候选项功能键的常量。

• static int VK_PRINTSCREEN

• static int VK_PROPS

• static int VK_Q

• static int VK_QUOTE

• static int VK_QUOTEDBL

• static int VK_R

• static int VK_RIGHT --非数字键盘右方向键的常量。

• static int VK_RIGHT_PARENTHESIS --“）”键的常量。

• static int VK_ROMAN_CHARACTERS --罗马字符功能键的常量。

• static int VK_S

• static int VK_SCROLL_LOCK

• static int VK_SEMICOLON -- 分号键“;”的常量。

• static int VK_SEPARATER --此常量已过时，仅出于向后兼容性而包含。

• static int VK_SEPARATOR --数字键盘分隔符键的常量。

• static int VK_SHIFT

• static int VK_SLASH -- 正斜杠键“/”的常量。

• static int VK_SPACE

• static int VK_STOP

• static int VK_SUBTRACT

• static int VK_T

• static int VK_TAB

• static int VK_U

• static int VK_UNDEFINED -- 此值用于指示keyCode未知。

• static int VK_UNDERSCORE --“_”键的常量。

• static int VK_UNDO

• static int VK_UP --非数字键盘向上箭头键的常量。

• static int VK_V

• static int VK_W

• static int VK_WINDOWS -- Microsoft Windows“Windows”键的常量。

• static int VK_X

• static int VK_Y

• static int VK_Z

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.event.InputEvent

• java.awt.event.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT MouseEvent 类

此事件指示在组件中发生了鼠标操作。此低级事件由组件对象为鼠标事件和鼠标移动事件生成。

• 鼠标按钮被按下

• 鼠标按钮被释放

• 鼠标按钮被点击（按下并释放）

• 鼠标光标进入组件几何图形的未遮挡部分

• 鼠标光标退出组件几何图形的未遮挡部分

• 鼠标被移动

• 鼠标被拖动

类声明

以下是java.awt.event.MouseEvent类的声明

public class MouseEvent
   extends InputEvent

字段

以下是java.awt.event.MouseEvent类的字段

• static int BUTTON1 --指示鼠标按钮 #1；由 getButton() 使用

• static int BUTTON2 --指示鼠标按钮 #2；由 getButton() 使用

• static int BUTTON3 --指示鼠标按钮 #3；由 getButton() 使用

• static int MOUSE_CLICKED --“鼠标点击”事件

• static int MOUSE_DRAGGED --“鼠标拖动”事件

• static int MOUSE_ENTERED --“鼠标进入”事件

• static int MOUSE_EXITED --“鼠标退出”事件

• static int MOUSE_FIRST --用于鼠标事件的 ID 范围中的第一个数字

• static int MOUSE_LAST --用于鼠标事件的 ID 范围中的最后一个数字

• static int MOUSE_MOVED --“鼠标移动”事件

• static int MOUSE_PRESSED --“鼠标按下”事件

• static int MOUSE_RELEASED --“鼠标释放”事件

• static int MOUSE_WHEEL --“鼠标滚轮”事件

• static int NOBUTTON --指示没有鼠标按钮；由 getButton() 使用

• static int VK_WINDOWS -- Microsoft Windows“Windows”键的常量。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.event.InputEvent

• java.awt.event.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT TextEvent 类

此类的对象表示文本事件。当在文本字段或文本区域中输入字符时，会生成 TextEvent。TextEvent 实例不包含生成事件的文本组件中当前的字符，而是为我们提供了其他方法来检索该信息。

类声明

以下是java.awt.event.TextEvent类的声明

public class TextEvent
   extends AWTEvent

字段

以下是java.awt.event.TextEvent类的字段

• static int TEXT_FIRST --用于文本事件的 ID 范围中的第一个数字。

• static int TEXT_LAST --用于文本事件的 ID 范围中的最后一个数字。

• static int TEXT_VALUE_CHANGED --此事件 ID 指示对象的文本已更改。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT WindowEvent 类

此类的对象表示窗口状态的更改。当窗口打开、关闭、激活、停用、图标化或取消图标化，或当焦点转移到窗口中或从窗口中转移时，窗口对象会生成此低级事件。

类声明

以下是java.awt.event.WindowEvent类的声明

public class WindowEvent
   extends ComponentEvent

字段

以下是java.awt.event.WindowEvent类的字段

• static int WINDOW_ACTIVATED --窗口激活事件类型。

• static int WINDOW_CLOSED --窗口关闭事件。

• static int WINDOW_CLOSING --“窗口即将关闭”事件。

• static int WINDOW_DEACTIVATED --窗口停用事件类型。

• static int WINDOW_DEICONIFIED --窗口取消图标化事件类型。

• static int WINDOW_FIRST --用于窗口事件的 ID 范围中的第一个数字。

• static int WINDOW_GAINED_FOCUS --窗口获得焦点事件类型。

• static int WINDOW_ICONIFIED --窗口图标化事件。

• static int WINDOW_LAST --用于窗口事件的 ID 范围中的最后一个数字。

• static int WINDOW_LOST_FOCUS --窗口失去焦点事件类型。

• static int WINDOW_OPENED --窗口打开事件。

• static int WINDOW_STATE_CHANGED --窗口状态更改事件类型。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.event.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT AdjustmentEvent 类

简介

类AdjustmentEvent表示由 Adjustable 对象发出的调整事件。

类声明

以下是java.awt.event.AdjustmentEvent类的声明

public class AdjustmentEvent
   extends AWTEvent

字段

以下是java.awt.Component类的字段

• static int ADJUSTMENT_FIRST --标记调整事件 ID 范围的第一个整数 ID。

• static int ADJUSTMENT_LAST --标记调整事件 ID 范围的最后一个整数 ID。

• static int ADJUSTMENT_VALUE_CHANGED --调整值更改事件。

• static int BLOCK_DECREMENT --块递减调整类型。

• static int BLOCK_INCREMENT --块递增调整类型。

• static int TRACK --绝对跟踪调整类型。

• static int UNIT_DECREMENT --单位递减调整类型。

• static int UNIT_INCREMENT --单位递增调整类型。

类构造函数

类方法

继承的方法

此接口继承自以下类的方法

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT ComponentEvent 类

简介

类ComponentEvent表示组件移动、大小更改或可见性更改

类声明

以下是java.awt.event.ComponentEvent类的声明

public class ComponentEvent
   extends AWTEvent

字段

以下是java.awt.Component类的字段

• static int COMPONENT_FIRST --用于组件事件的 ID 范围中的第一个数字。

• static int COMPONENT_HIDDEN --此事件指示组件已呈隐藏状态。

• static int COMPONENT_LAST --用于组件事件的 ID 范围中的最后一个数字。

• static int COMPONENT_MOVED --此事件指示组件的位置已更改。

• static int COMPONENT_RESIZED -- 此事件表示组件的大小发生了变化。

• static int COMPONENT_SHOWN -- 此事件表示组件变得可见。

类构造函数

类方法

继承的方法

此接口继承自以下类的方法

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT ContainerEvent 类

简介

ContainerEvent 类表示容器的内容发生了变化，因为添加或删除了组件。

类声明

以下是java.awt.event.ContainerEvent类的声明

public class ContainerEvent
   extends ComponentEvent

字段

以下是java.awt.Component类的字段

• static int COMPONENT_ADDED -- 此事件表示组件已添加到容器中。

• static int COMPONENT_REMOVED -- 此事件表示组件已从容器中移除。

• static int CONTAINER_FIRST -- 用于容器事件的 ID 范围中的第一个数字。

• static int CONTAINER_LAST -- 用于容器事件的 ID 范围中的最后一个数字。

类构造函数

继承的方法

此类继承自以下类的方法

• java.awt.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT MouseMotionEvent 类

简介

MouseMotionEvent 接口指示在组件中发生了鼠标操作。当鼠标被拖动或移动时，组件对象会生成此低级事件。

类声明

以下是java.awt.event.MouseMotionEvent类的声明

public class MouseMotionEvent
   extends InputEvent

接口方法

继承的方法

此接口继承自以下类的方法

• java.awt.event.InputEvent

• java.awt.event.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT PaintEvent 类

简介

PaintEvent 类用于确保 paint/update 方法调用与从事件队列传递的其他事件一起序列化。

类声明

以下是java.awt.event.PaintEvent类的声明

public class PaintEvent
   extends ComponentEvent

字段

以下是java.awt.Component类的字段

• static int PAINT -- 绘制事件类型。

• static int PAINT_FIRST -- 标记绘制事件 ID 范围的第一个整数 ID。

• static int PAINT_LAST -- 标记绘制事件 ID 范围的最后一个整数 ID。

• static int UPDATE -- 更新事件类型。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.ComponentEvent

• java.awt.AWTEvent

• java.util.EventObject

• java.lang.Object

AWT 事件监听器

事件监听器表示负责处理事件的接口。Java 为我们提供了各种事件监听器类，但我们将讨论那些更常用的类。每个事件监听器方法都有一个参数作为对象，该对象是 EventObject 类的子类。例如，鼠标事件监听器方法将接受 MouseEvent 的实例，其中 MouseEvent 派生自 EventObject。

EventListner 接口

这是一个标记接口，每个监听器接口都必须扩展它。此类在 java.util 包中定义。

类声明

以下是java.util.EventListener接口的声明

public interface EventListener

AWT 事件监听器接口

以下是常用事件监听器的列表。

AWT ActionListener 接口

处理 ActionEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addActionListener() 方法注册该对象。当动作事件发生时，将调用该对象的 actionPerformed 方法。

接口声明

以下是java.awt.event.ActionListener接口的声明

public interface ActionListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

ActionListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showActionListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showActionListenerDemo(){
      headerLabel.setText("Listener in action: ActionListener");      

      ScrollPane panel = new ScrollPane();      
      panel.setBackground(Color.magenta);            

      Button okButton = new Button("OK");

      okButton.addActionListener(new CustomActionListener());        
      panel.add(okButton);
      controlPanel.add(panel);

      mainFrame.setVisible(true); 
   }

   class CustomActionListener implements ActionListener{

      public void actionPerformed(ActionEvent e) {
         statusLabel.setText("Ok Button Clicked.");
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT ComponentListener 接口

处理 ComponentEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addComponentListener() 方法注册该对象。组件事件仅出于信息目的而引发。

接口声明

以下是java.awt.event.ComponentListener接口的声明

public interface ComponentListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

ComponentListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showComponentListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showComponentListenerDemo(){
      headerLabel.setText("Listener in action: ComponentListener");      

      ScrollPane panel = new ScrollPane();      
      panel.setBackground(Color.magenta);            

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");
      panel.add(msglabel);

      msglabel.addComponentListener(new CustomComponentListener());      
      controlPanel.add(panel);
      mainFrame.setVisible(true);  
   }

   class CustomComponentListener implements ComponentListener {

      public void componentResized(ComponentEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " resized. ");
      }

      public void componentMoved(ComponentEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " moved. ");
      }

      public void componentShown(ComponentEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " shown. ");
      }

      public void componentHidden(ComponentEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " hidden. ");
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT ItemListener 接口

处理 ItemEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addItemListener() 方法注册该对象。当动作事件发生时，将调用该对象的 itemStateChanged 方法。

接口声明

以下是java.awt.event.ItemListener接口的声明

public interface ItemListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

ItemListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showItemListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showItemListenerDemo(){
      headerLabel.setText("Listener in action: ItemListener");      
      Checkbox chkApple = new Checkbox("Apple");
      Checkbox chkMango = new Checkbox("Mango");
      Checkbox chkPeer = new Checkbox("Peer");
      
      chkApple.addItemListener(new CustomItemListener());
      chkMango.addItemListener(new CustomItemListener());
      chkPeer.addItemListener(new CustomItemListener());

      controlPanel.add(chkApple);
      controlPanel.add(chkMango);
      controlPanel.add(chkPeer);               
      mainFrame.setVisible(true); 
   }

   class CustomItemListener implements ItemListener {
      public void itemStateChanged(ItemEvent e) {
         statusLabel.setText(e.getItem()
         +" Checkbox: " 
         + (e.getStateChange()==1?"checked":"unchecked"));
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT KeyListener 接口

处理 KeyEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addKeyListener() 方法注册该对象。

接口声明

以下是java.awt.event.KeyListener接口的声明

public interface KeyListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

KeyListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private TextField textField;
   
   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showKeyListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showKeyListenerDemo(){
      headerLabel.setText("Listener in action: KeyListener");      

      textField  = new TextField(10);

      textField.addKeyListener(new CustomKeyListener());
      Button okButton = new Button("OK");
      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Entered text: " + textField.getText());                
         }
      });

      controlPanel.add(textField);
      controlPanel.add(okButton);    
      mainFrame.setVisible(true);  
   }

   class CustomKeyListener implements KeyListener{
      public void keyTyped(KeyEvent e) {           
      }

      public void keyPressed(KeyEvent e) {
         if(e.getKeyCode() == KeyEvent.VK_ENTER){
            statusLabel.setText("Entered text: " + textField.getText());
         }
      }

      public void keyReleased(KeyEvent e) {            
      }    
   } 
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT MouseListener 接口

处理 MouseEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addMouseListener() 方法注册该对象。

接口声明

以下是java.awt.event.MouseListener接口的声明

public interface MouseListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

MouseListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showMouseListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMouseListenerDemo(){
      headerLabel.setText("Listener in action: MouseListener");      

      Panel panel = new Panel();      
      panel.setBackground(Color.magenta);
      panel.setLayout(new FlowLayout());        
      panel.addMouseListener(new CustomMouseListener());

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      msglabel.addMouseListener(new CustomMouseListener());
      panel.add(msglabel);

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }

   class CustomMouseListener implements MouseListener{

      public void mouseClicked(MouseEvent e) {
         statusLabel.setText("Mouse Clicked: ("
         +e.getX()+", "+e.getY() +")");
      }   

      public void mousePressed(MouseEvent e) {
      }

      public void mouseReleased(MouseEvent e) {
      }

      public void mouseEntered(MouseEvent e) {
      }

      public void mouseExited(MouseEvent e) {
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT TextListener 接口

处理 TextEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addTextListener() 方法注册该对象。

接口声明

以下是java.awt.event.TextListener接口的声明

public interface TextListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

TextListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private TextField textField;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showTextListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showTextListenerDemo(){
      headerLabel.setText("Listener in action: TextListener");      

      textField  = new TextField(10);

      textField.addTextListener(new CustomTextListener());
      Button okButton = new Button("OK");
      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Entered text: " 
            + textField.getText());                
         }
      });

      controlPanel.add(textField);
      controlPanel.add(okButton);    
      mainFrame.setVisible(true);  
   }

   class CustomTextListener implements TextListener {
      public void textValueChanged(TextEvent e) {
         statusLabel.setText("Entered text: " + textField.getText());               
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT WindowListener 接口

处理 WindowEvent 的类应该实现此接口。该类的对象必须与组件注册。可以使用 addWindowListener() 方法注册该对象。

接口声明

以下是java.awt.event.WindowListener接口的声明

public interface WindowListener
   extends EventListener

接口方法

继承的方法

此接口继承自以下接口

• java.awt.EventListener

WindowListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showWindowListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showWindowListenerDemo(){
      headerLabel.setText("Listener in action: WindowListener");      

      Button okButton = new Button("OK");

      aboutFrame = new Frame();
      aboutFrame.setSize(300,200);;
      aboutFrame.setTitle("WindowListener Demo");
      aboutFrame.addWindowListener(new CustomWindowListener());

      Label msgLabel = new Label("Welcome to tutorialspoint.");
      msgLabel.setAlignment(Label.CENTER);
      msgLabel.setSize(100,100);
      aboutFrame.add(msgLabel);
      aboutFrame.setVisible(true);
   }

   class CustomWindowListener implements WindowListener {
      public void windowOpened(WindowEvent e) {
      }

      public void windowClosing(WindowEvent e) {
         aboutFrame.dispose();      
      }
      
      public void windowClosed(WindowEvent e) {
      }

      public void windowIconified(WindowEvent e) {
      }

      public void windowDeiconified(WindowEvent e) {
      }

      public void windowActivated(WindowEvent e) {
      }

      public void windowDeactivated(WindowEvent e) {
      }
   }   
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT AdjustmentListener 接口

简介

AdjustmentListener 接口用于接收调整事件。处理调整事件的类需要实现此接口。

类声明

以下是java.awt.event.AdjustmentListener接口的声明

public interface AdjustmentListener
extends EventListener

接口方法

继承的方法

此类继承自以下接口

• java.awt.event.EventListener

AdjustmentListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showAdjustmentListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showAdjustmentListenerDemo(){
      headerLabel.setText("Listener in action: AdjustmentListener");      

      ScrollPane panel = new ScrollPane();      
      panel.setBackground(Color.magenta);
      panel.getHAdjustable().addAdjustmentListener(new CustomAdjustmentListener());

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);   
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");
      panel.add(msglabel);
      
      controlPanel.add(panel);
      mainFrame.setVisible(true);  
   }

   class CustomAdjustmentListener implements AdjustmentListener {
      public void adjustmentValueChanged(AdjustmentEvent e) {
         statusLabel.setText("Adjustment value: "+Integer.toString(e.getValue()));
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT ContainerListener 接口

简介

ContainerListener 接口用于接收容器事件。处理容器事件的类需要实现此接口。

类声明

以下是java.awt.event.ContainerListener接口的声明

public interface ContainerListener
extends EventListener

接口方法

继承的方法

此类继承自以下接口

• java.awt.event.EventListener

AdjustmentListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showContainerListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showContainerListenerDemo(){
      headerLabel.setText("Listener in action: ContainerListener");      

      ScrollPane panel = new ScrollPane();      
      panel.setBackground(Color.magenta);            
      panel.addContainerListener(new CustomContainerListener());  

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");
      panel.add(msglabel);
   
      controlPanel.add(panel);
      mainFrame.setVisible(true);  
   }

   class CustomContainerListener implements ContainerListener {
      public void componentAdded(ContainerEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " added. ");
      }

      public void componentRemoved(ContainerEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " removed. ");
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT MouseMotionListener 接口

简介

MouseMotionListener 接口用于接收组件上的鼠标移动事件。处理鼠标移动事件的类需要实现此接口。

类声明

以下是java.awt.event.MouseMotionListener接口的声明

public interface MouseMotionListener
extends EventListener

接口方法

继承的方法

此类继承自以下接口

• java.awt.event.EventListener

MouseMotionListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showMouseMotionListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMouseMotionListenerDemo(){
      headerLabel.setText("Listener in action: MouseMotionListener");      

      Panel panel = new Panel();      
      panel.setBackground(Color.magenta);
      panel.setLayout(new FlowLayout());        
      panel.addMouseMotionListener(new CustomMouseMotionListener());

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");
      panel.add(msglabel);

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }   

   class CustomMouseMotionListener implements MouseMotionListener {

      public void mouseDragged(MouseEvent e) {
         statusLabel.setText("Mouse Dragged: ("+e.getX()+", "+e.getY() +")");
      }

      public void mouseMoved(MouseEvent e) {
         statusLabel.setText("Mouse Moved: ("+e.getX()+", "+e.getY() +")");
      }    
   }    
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT FocusListener 接口

简介

FocusListener 接口用于接收键盘焦点事件。处理焦点事件的类需要实现此接口。

类声明

以下是java.awt.event.FocusListener接口的声明

public interface FocusListener
extends EventListener

接口方法

继承的方法

此类继承自以下接口

• java.awt.event.EventListener

FocusListener 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtListenerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtListenerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtListenerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtListenerDemo  awtListenerDemo = new AwtListenerDemo();  
      awtListenerDemo.showFocusListenerDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
   
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

       
   private void showFocusListenerDemo(){

      headerLabel.setText("Listener in action: FocusListener");      

      Button okButton = new Button("OK");
      Button cancelButton = new Button("Cancel");
      okButton.addFocusListener(new CustomFocusListener());  
      cancelButton.addFocusListener(new CustomFocusListener());  

      controlPanel.add(okButton);
      controlPanel.add(cancelButton);     
      mainFrame.setVisible(true);  
   }

   class CustomFocusListener implements FocusListener{
      public void focusGained(FocusEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " gained focus. ");
      }

      public void focusLost(FocusEvent e) {
         statusLabel.setText(statusLabel.getText() 
         + e.getComponent().getClass().getSimpleName() + " lost focus. ");
      }
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtListenerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtListenerDemo

验证以下输出

AWT 事件适配器

适配器是用于接收各种事件的抽象类。这些类中的方法为空。这些类存在是为了方便创建监听器对象。

AWT 适配器

以下是监听 AWT 中 GUI 事件时常用的适配器列表。

AWT FocusAdapter 类

简介

FocusAdapter 类是一个用于接收键盘焦点事件的抽象（适配器）类。此类中的所有方法都为空。此类是用于创建监听器对象的便捷类。

类声明

以下是java.awt.event.FocusAdapter类的声明

public abstract class FocusAdapter
   extends Object
      implements FocusListener

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

FocusAdapter 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtAdapterDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtAdapterDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtAdapterDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtAdapterDemo  awtAdapterDemo = new AwtAdapterDemo();        
      awtAdapterDemo.showFocusAdapterDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showFocusAdapterDemo(){

      headerLabel.setText("Listener in action: FocusAdapter");      

      Button okButton = new Button("OK");
      Button cancelButton = new Button("Cancel");
      okButton.addFocusListener(new FocusAdapter(){
         public void focusGained(FocusEvent e) {
            statusLabel.setText(statusLabel.getText() 
            + e.getComponent().getClass().getSimpleName() 
            + " gained focus. ");
         }
      });  
      
      cancelButton.addFocusListener(new FocusAdapter(){
         public void focusLost(FocusEvent e) {
            statusLabel.setText(statusLabel.getText() 
            + e.getComponent().getClass().getSimpleName() 
            + " lost focus. ");
         }
      });  
      
      controlPanel.add(okButton);
      controlPanel.add(cancelButton);     
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtAdapterDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtAdapterDemo

验证以下输出

AWT KeyAdapter 类

简介

KeyAdapter 类是一个用于接收键盘事件的抽象（适配器）类。此类中的所有方法都为空。此类是用于创建监听器对象的便捷类。

类声明

以下是java.awt.event.KeyAdapter类的声明

public abstract class KeyAdapter
   extends Object
      implements KeyListener

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

KeyAdapter 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtAdapterDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtAdapterDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtAdapterDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtAdapterDemo  awtAdapterDemo = new AwtAdapterDemo();        
      awtAdapterDemo.showKeyAdapterDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showKeyAdapterDemo(){
      headerLabel.setText("Listener in action: KeyAdapter");      

      final TextField textField = new TextField(10);

      textField.addKeyListener(new KeyAdapter() {
         public void keyPressed(KeyEvent e) {                
            if(e.getKeyCode() == KeyEvent.VK_ENTER){
               statusLabel.setText("Entered text: " + textField.getText());
            }
         }        
      });
      Button okButton = new Button("OK");
      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("Entered text: " + textField.getText());                
         }
      });

      controlPanel.add(textField);
      controlPanel.add(okButton);    
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtAdapterDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtAdapterDemo

验证以下输出

AWT MouseAdapter 类

简介

MouseAdapter 类是一个用于接收鼠标事件的抽象（适配器）类。此类中的所有方法都为空。此类是用于创建监听器对象的便捷类。

类声明

以下是java.awt.event.MouseAdapter类的声明

public abstract class MouseAdapter
   extends Object
      implements MouseListener, MouseWheelListener, MouseMotionListener

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

MouseAdapter 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtAdapterDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtAdapterDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtAdapterDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtAdapterDemo  awtAdapterDemo = new AwtAdapterDemo();  
      awtAdapterDemo.showMouseAdapterDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMouseAdapterDemo(){
      headerLabel.setText("Listener in action: MouseAdapter");      

      Panel panel = new Panel();      
      panel.setBackground(Color.magenta);
      panel.setLayout(new FlowLayout());        
      panel.addMouseListener(new MouseAdapter(){
         public void mouseClicked(MouseEvent e) {
            statusLabel.setText("Mouse Clicked: ("
            +e.getX()+", "+e.getY() +")");
         }                
      });

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      msglabel.addMouseListener(new MouseAdapter(){
         public void mouseClicked(MouseEvent e) {
            statusLabel.setText("Mouse Clicked: ("
            +e.getX()+", "+e.getY() +")");
         }                
      });
      panel.add(msglabel);
      controlPanel.add(panel);
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtAdapterDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtAdapterDemo

验证以下输出

AWT MouseMotionAdapter 类

简介

MouseMotionAdapter 类是一个用于接收鼠标移动事件的抽象（适配器）类。此类中的所有方法都为空。此类是用于创建监听器对象的便捷类。

类声明

以下是java.awt.event.MouseMotionAdapter类的声明

public abstract class MouseMotionAdapter
   extends Object
      implements MouseMotionListener

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

MouseMotionAdapter 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtAdapterDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtAdapterDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtAdapterDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtAdapterDemo  awtAdapterDemo = new AwtAdapterDemo();        
      awtAdapterDemo.showMouseMotionAdapterDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMouseMotionAdapterDemo(){
      headerLabel.setText("Listener in action: MouseMotionAdapter");      

      Panel panel = new Panel();      
      panel.setBackground(Color.magenta);
      panel.setLayout(new FlowLayout());        
      panel.addMouseMotionListener(new MouseMotionAdapter(){
         public void mouseMoved(MouseEvent e) {
            statusLabel.setText("Mouse Moved: ("+e.getX()+", "+e.getY() +")");
         }                
      });

      Label msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");
      panel.add(msglabel);

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtAdapterDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtAdapterDemo

验证以下输出

AWT WindowAdapter 类

简介

WindowAdapter 类是一个用于接收窗口事件的抽象（适配器）类。此类中的所有方法都为空。此类是用于创建监听器对象的便捷类。

类声明

以下是java.awt.event.WindowAdapter类的声明

public abstract class WindowAdapter
   extends Object
      implements WindowListener, WindowStateListener, WindowFocusListener

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

WindowAdapter 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtAdapterDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtAdapterDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AwtAdapterDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtAdapterDemo  awtAdapterDemo = new AwtAdapterDemo();        
      awtAdapterDemo.showWindowAdapterDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showWindowAdapterDemo(){
      headerLabel.setText("Listener in action: WindowAdapter");      

      Button okButton = new Button("OK");

      final Frame aboutFrame = new Frame();
      aboutFrame.setSize(300,200);;
      aboutFrame.setTitle("WindowAdapter Demo");
      aboutFrame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent windowEvent){
               aboutFrame.dispose();
         }        
      });    
      Label msgLabel = new Label("Welcome to tutorialspoint.");
      msgLabel.setAlignment(Label.CENTER);
      msgLabel.setSize(100,100);
      aboutFrame.add(msgLabel);
      aboutFrame.setVisible(true);
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtAdapterDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtAdapterDemo

验证以下输出

AWT 布局

简介

布局是指容器内组件的排列方式。换句话说，就是将组件放置在容器内的特定位置。布局控件的任务由布局管理器自动完成。

布局管理器

布局管理器会自动将所有组件放置在容器内。如果我们不使用布局管理器，组件也会由默认的布局管理器进行定位。也可以手动布局控件，但由于以下两个原因，这会变得非常困难。

• 处理容器内大量控件非常繁琐。

• 通常，当我们需要排列组件时，不会给出组件的宽度和高度信息。

Java 为我们提供了各种布局管理器来定位控件。诸如大小、形状和排列等属性在不同的布局管理器之间有所不同。当 Applet 或应用程序窗口的大小发生变化时，组件的大小、形状和排列也会相应地发生变化，即布局管理器会适应 AppletViewer 或应用程序窗口的尺寸。

布局管理器与每个容器对象相关联。每个布局管理器都是实现 LayoutManager 接口的类的对象。

以下是定义布局管理器功能的接口和类。

AWT LayoutManager 接口

简介

接口LayoutManager 用于定义知道如何布局容器的类的接口。

类声明

以下是java.awt.LayoutManager 接口的声明

public interface LayoutManager

接口方法

AWT LayoutManager2 接口

简介

接口LayoutManger 用于定义知道如何基于布局约束对象布局容器的类的接口。

类声明

以下是java.awt.LayoutManager2 接口的声明

public interface LayoutManger2
   extends LayoutManager

接口方法

AWT BorderLayout 类

简介

类BorderLayout 将组件排列在五个区域中：东、西、北、南和中。每个区域只能包含一个组件，并且每个区域中的每个组件都由相应的常量 NORTH、SOUTH、EAST、WEST 和 CENTER 标识。

类声明

以下是java.awt.BorderLayout 类的声明

public class BorderLayout
   extends Object
      implements LayoutManager2, Serializable

字段

以下是java.awt.BorderLayout 类的字段

• static String AFTER_LAST_LINE -- PAGE_END 的同义词。

• static String AFTER_LINE_ENDS -- LINE_END 的同义词。

• static String BEFORE_FIRST_LINE -- PAGE_START 的同义词。

• static String BEFORE_LINE_BEGINS -- LINE_START 的同义词。

• static String CENTER -- 中心布局约束（容器的中间）。

• static String EAST -- 东部布局约束（容器的右侧）。

• static String LINE_END -- 组件位于布局的行方向末尾。

• static String LINE_START -- 组件位于布局的行方向开头。

• static String NORTH -- 北部布局约束（容器的顶部）。

• static String PAGE_END -- 组件位于布局内容的最后一行之后。

• static String PAGE_START -- 组件位于布局内容的第一行之前。

• static String SOUTH -- 南部布局约束（容器的底部）。

• static String WEST -- 西部布局约束（容器的左侧）。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

BorderLayout 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtLayoutDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtLayoutDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtLayoutDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtLayoutDemo  awtLayoutDemo = new AwtLayoutDemo();  
      awtLayoutDemo.showBorderLayoutDemo();       
   }
      
   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showBorderLayoutDemo(){
      headerLabel.setText("Layout in action: BorderLayout");      

      Panel panel = new Panel();
      panel.setBackground(Color.darkGray);
      panel.setSize(300,300);
      BorderLayout layout = new BorderLayout();
      layout.setHgap(10);
      layout.setVgap(10);
      panel.setLayout(layout);        
	  
      panel.add(new Button("Center"),BorderLayout.CENTER);
      panel.add(new Button("Line Start"),BorderLayout.LINE_START); 
      panel.add(new Button("Line End"),BorderLayout.LINE_END);
      panel.add(new Button("East"),BorderLayout.EAST);   
      panel.add(new Button("West"),BorderLayout.WEST); 
      panel.add(new Button("North"),BorderLayout.NORTH); 
      panel.add(new Button("South"),BorderLayout.SOUTH); 

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtlayoutDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtlayoutDemo

验证以下输出

AWT CardLayout 类

简介

类CardLayout 将容器中的每个组件都排列成卡片。一次只能看到一张卡片，容器充当卡片堆栈。

类声明

以下是java.awt.CardLayout 类的声明

public class CardLayout
   extends Object
      implements LayoutManager2, Serializable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

CardLayout 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtLayoutDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtLayoutDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtLayoutDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtLayoutDemo  awtLayoutDemo = new AwtLayoutDemo();  
      awtLayoutDemo.showCardLayoutDemo();       
   }
      
   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showCardLayoutDemo(){
      headerLabel.setText("Layout in action: CardLayout");      

      final Panel panel = new Panel();
      panel.setBackground(Color.CYAN);
      panel.setSize(300,300);

      CardLayout layout = new CardLayout();
      layout.setHgap(10);
      layout.setVgap(10);
      panel.setLayout(layout);        

      Panel buttonPanel = new Panel(new FlowLayout());

      buttonPanel.add(new Button("OK"));
      buttonPanel.add(new Button("Cancel"));    

      Panel textBoxPanel = new Panel(new FlowLayout());

      textBoxPanel.add(new Label("Name:"));
      textBoxPanel.add(new TextField(20));

      panel.add("Button", buttonPanel);
      panel.add("Text", textBoxPanel);

      Choice choice = new Choice();
      choice.add("Button");
      choice.add("Text");

      choice.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            CardLayout cardLayout = (CardLayout)(panel.getLayout());
            cardLayout.show(panel, (String)e.getItem());
         }
      });
      controlPanel.add(choice);
      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtlayoutDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtlayoutDemo

验证以下输出

AWT FlowLayout 类

简介

类FlowLayout 以从左到右的流方式排列组件。

类声明

以下是java.awt.FlowLayout 类的声明

public class FlowLayout
   extends Object
      implements LayoutManager, Serializable

字段

以下是java.awt.BorderLayout 类的字段

• static int CENTER -- 此值表示组件的每一行都应居中。

• static int LEADING -- 此值表示组件的每一行都应与容器方向的前缘对齐，例如，在从左到右的方向中对齐到左侧。

• static int LEFT -- 此值表示组件的每一行都应左对齐。

• static int RIGHT -- 此值表示组件的每一行都应右对齐。

• static int TRAILING -- 此值表示组件的每一行都应与容器方向的后缘对齐，例如，在从左到右的方向中对齐到右侧。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

FlowLayout 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtLayoutDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtLayoutDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtLayoutDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtLayoutDemo  awtLayoutDemo = new AwtLayoutDemo();  
      awtLayoutDemo.showFlowLayoutDemo();       
   }
      
   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showFlowLayoutDemo(){
      headerLabel.setText("Layout in action: FlowLayout");      

      Panel panel = new Panel();
      panel.setBackground(Color.darkGray);
      panel.setSize(200,200);
      FlowLayout layout = new FlowLayout();
      layout.setHgap(10);              
      layout.setVgap(10);
      panel.setLayout(layout);        
      panel.add(new Button("OK"));
      panel.add(new Button("Cancel"));       

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtlayoutDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtlayoutDemo

验证以下输出

AWT GridLayout 类

简介

类GridLayout 将组件排列在矩形网格中。

类声明

以下是java.awt.GridLayout 类的声明

public class GridLayout
   extends Object
      implements LayoutManager, Serializable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

GridLayout 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtLayoutDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtLayoutDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtLayoutDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtLayoutDemo  awtLayoutDemo = new AwtLayoutDemo();  
      awtLayoutDemo.showGridLayoutDemo();       
   }
      
   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showGridLayoutDemo(){
      headerLabel.setText("Layout in action: GridLayout");      

      Panel panel = new Panel();
      panel.setBackground(Color.darkGray);
      panel.setSize(300,300);
      GridLayout layout = new GridLayout(0,3);
      layout.setHgap(10);
      layout.setVgap(10);
      
      panel.setLayout(layout);        
      panel.add(new Button("Button 1"));
      panel.add(new Button("Button 2")); 
      panel.add(new Button("Button 3")); 
      panel.add(new Button("Button 4")); 
      panel.add(new Button("Button 5")); 
      controlPanel.add(panel);
      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtlayoutDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtlayoutDemo

验证以下输出

AWT GridBagLayout 类

简介

类GridBagLayout 以水平和垂直方式排列组件。

类声明

以下是java.awt.GridBagLayout 类的声明

public class GridBagLayout
   extends Object
      implements LayoutManager2, Serializable

字段

以下是java.awt.BorderLayout 类的字段

• double[] columnWeights -- 此字段保存对列权重的覆盖。

• int[] columnWidths -- 此字段保存对列最小宽度的覆盖。

• protected Hashtable comptable -- 此哈希表维护组件与其网格包约束之间的关联。

• protected GridBagConstraints defaultConstraints -- 此字段保存一个包含默认值的网格包约束实例，因此，如果组件没有与其关联的网格包约束，则该组件将被分配 defaultConstraints 的副本。

• protected java.awt.GridBagLayoutInfo layoutInfo -- 此字段保存网格包的布局信息。

• protected static int MAXGRIDSIZE -- 网格包布局可以布局的最大网格位置数（水平和垂直）。

• protected static int MINSIZE -- 网格包布局可以布局的最小网格。

• protected static int PREFERREDSIZE -- 网格包布局可以布局的首选网格大小。

• int[] rowHeights -- 此字段保存对行最小高度的覆盖。

• double[] rowWeights -- 此字段保存对行权重的覆盖。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

GridBagLayout 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtLayoutDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtLayoutDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtLayoutDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtLayoutDemo  awtLayoutDemo = new AwtLayoutDemo();  
      awtLayoutDemo.showGridBagLayoutDemo();       
   }
      
   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showGridBagLayoutDemo(){
      headerLabel.setText("Layout in action: GridBagLayout");      

      Panel panel = new Panel();
      panel.setBackground(Color.darkGray);
      panel.setSize(300,300);
      GridBagLayout layout = new GridBagLayout();

      panel.setLayout(layout);        
      GridBagConstraints gbc = new GridBagConstraints();

      gbc.fill = GridBagConstraints.HORIZONTAL;
      gbc.gridx = 0;
      gbc.gridy = 0;
      panel.add(new Button("Button 1"),gbc);

      gbc.gridx = 1;
      gbc.gridy = 0;
      panel.add(new Button("Button 2"),gbc); 

      gbc.fill = GridBagConstraints.HORIZONTAL;
      gbc.ipady = 20;   
      gbc.gridx = 0;
      gbc.gridy = 1;
      panel.add(new Button("Button 3"),gbc); 

      gbc.gridx = 1;
      gbc.gridy = 1;       
      panel.add(new Button("Button 4"),gbc);  

      gbc.gridx = 0;
      gbc.gridy = 2;      
      gbc.fill = GridBagConstraints.HORIZONTAL;
      gbc.gridwidth = 2;
      panel.add(new Button("Button 5"),gbc);  

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtlayoutDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtlayoutDemo

验证以下输出

AWT 容器

容器是 AWT GUI 组件的组成部分。容器提供了一个组件可以放置的空间。AWT 中的容器本身就是一个组件，它增加了向自身添加组件的功能。以下是要考虑的要点。

• Container 的子类称为 Containter。例如 Panel、Frame 和 Window。

• Container 只能向自身添加 Component。

• 每个容器中都存在一个默认布局，可以使用 setLayout 方法覆盖它。

AWT Container 类

简介

类Container是 AWT 容器的超类。Container 对象可以包含其他 AWT 组件。

类声明

以下是java.awt.Container类的声明

public class Container
   extends Component

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Component

• java.lang.Object

AWT Panel 类

简介

类Panel是最简单的容器类。它提供了一个空间，应用程序可以在其中附加任何其他组件，包括其他面板。它使用 FlowLayout 作为默认布局管理器。

类声明

以下是java.awt.Panel类的声明

public class Panel
   extends Container
      implements Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Container

• java.awt.Component

• java.lang.Object

Panel 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtContainerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtContainerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtContainerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtContainerDemo  awtContainerDemo = new AwtContainerDemo();          
      awtContainerDemo.showPanelDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);
   
      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showPanelDemo(){
      headerLabel.setText("Container in action: Panel");      

      Panel panel = new Panel();
      panel.setBackground(Color.magenta);
      panel.setLayout(new FlowLayout());        
      panel.add(msglabel);

      controlPanel.add(panel);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtContainerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtContainerDemo

验证以下输出

AWT Frame 类

简介

类Frame是一个带边框和标题的顶级窗口。它使用 BorderLayout 作为默认布局管理器。

类声明

以下是java.awt.Frame类的声明

public class Frame
   extends Window
      implements MenuContainer

字段

以下是java.awt.Frame类的字段

• static float BOTTOM_ALIGNMENT -- getAlignmentY 的易用性常量。

• static int CROSSHAIR_CURSOR -- 已弃用。由 Cursor.CROSSHAIR_CURSOR 替换。

• static int DEFAULT_CURSOR -- 已弃用。由 Cursor.DEFAULT_CURSOR 替换。

• static int E_RESIZE_CURSOR -- 已弃用。由 Cursor.E_RESIZE_CURSOR 替换。

• static int HAND_CURSOR -- 已弃用。由 Cursor.HAND_CURSOR 替换。

• static int ICONIFIED -- 此状态位指示框架已最小化。

• static int MAXIMIZED_BOTH -- 此状态位掩码指示框架已完全最大化（即水平和垂直方向）。

• static int MAXIMIZED_HORIZ -- 此状态位指示框架在水平方向上最大化。

• static int MAXIMIZED_VERT -- 此状态位指示框架在垂直方向上最大化。

• static int MOVE_CURSOR -- 已弃用。由 Cursor.MOVE_CURSOR 替换。

• static int N_RESIZE_CURSOR -- 已弃用。由 Cursor.N_RESIZE_CURSOR 替换。

• static int NE_RESIZE_CURSOR -- 已弃用。由 Cursor.NE_RESIZE_CURSOR 替换。

• static int NORMAL -- 框架处于“正常”状态。

• static int NW_RESIZE_CURSOR -- 已弃用。由 Cursor.NW_RESIZE_CURSOR 替换。

• static int S_RESIZE_CURSOR -- 已弃用。由 Cursor.S_RESIZE_CURSOR 替换。

• static int SE_RESIZE_CURSOR -- 已弃用。由 Cursor.SE_RESIZE_CURSOR 替换。

• static int SW_RESIZE_CURSOR -- 已弃用。由 Cursor.SW_RESIZE_CURSOR 替换。

• static int TEXT_CURSOR -- 已弃用。由 Cursor.TEXT_CURSOR 替换。

• static int W_RESIZE_CURSOR -- 已弃用。由 Cursor.W_RESIZE_CURSOR 替换。

• static int WAIT_CURSOR -- 已弃用。由 Cursor.WAIT_CURSOR 替换。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Window

• java.awt.Container

• java.awt.Component

• java.lang.Object

Frame 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtContainerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtContainerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtContainerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtContainerDemo  awtContainerDemo = new AwtContainerDemo();          
      awtContainerDemo.showFrameDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);
   
      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }
   
   private void showFrameDemo(){
      headerLabel.setText("Container in action: Frame");   

      final Frame frame = new Frame();
      frame.setSize(300, 300);
      frame.setLayout(new FlowLayout());       
      frame.add(msglabel);
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            frame.dispose();
         }        
      });    
      Button okButton = new Button("Open a Frame");

      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            statusLabel.setText("A Frame shown to the user.");
            frame.setVisible(true);
         }
      });
      controlPanel.add(okButton);

      mainFrame.setVisible(true);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtContainerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtContainerDemo

验证以下输出

AWT 窗口类

简介

Window 类是一个没有边框和菜单栏的顶级窗口。它使用 BorderLayout 作为默认布局管理器。

类声明

以下是 java.awt.Window 类的声明

public class Window
   extends Container
      implements Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.Window

• java.awt.Container

• java.awt.Component

• java.lang.Object

Window 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AwtContainerDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AwtContainerDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;
   private Label msglabel;

   public AwtContainerDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AwtContainerDemo  awtContainerDemo = new AwtContainerDemo();          
      awtContainerDemo.showFrameDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);
   
      msglabel = new Label();
      msglabel.setAlignment(Label.CENTER);
      msglabel.setText("Welcome to TutorialsPoint AWT Tutorial.");

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }
   
   private void showWindowDemo(){
      headerLabel.setText("Container in action: Window");   
      final MessageWindow window = 
         new MessageWindow(mainFrame,
         "Welcome to TutorialsPoint AWT Tutorial.");

      Button okButton = new Button("Open a Window");
      okButton.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            window.setVisible(true);
            statusLabel.setText("A Window shown to the user.");                
         }
      });
      controlPanel.add(okButton);
      mainFrame.setVisible(true);  
   }

   class MessageWindow extends Window{
      private String message; 

      public MessageWindow(Frame parent, String message) { 
         super(parent);               
         this.message = message; 
         setSize(300, 300);       
         setLocationRelativeTo(parent);
         setBackground(Color.gray);
      }

      public void paint(Graphics g) { 
         super.paint(g);
         g.drawRect(0,0,getSize().width - 1,getSize().height - 1); 
         g.drawString(message,50,150); 
      } 
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtContainerDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtContainerDemo

验证以下输出

AWT 菜单类

众所周知，每个顶级窗口都与一个菜单栏关联。此菜单栏包含可供最终用户使用的各种菜单选项。此外，每个选项都包含选项列表，称为下拉菜单。Menu 和 MenuItem 控件是 MenuComponent 类的子类。

菜单层次结构

AWT MenuComponent 类

简介

MenuComponent 是一个抽象类，它是所有与菜单相关的组件的超类。

类声明

以下是 **java.awt.MenuComponent** 类的声明

public abstract class MenuComponent
   extends Object
      implements Serializable

类构造函数

类方法

类方法

继承的方法

此类继承自以下类的方法

• java.awt.MenuComponent

• java.lang.Object

MenuBar 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTMenuDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AWTMenuDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AWTMenuDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AWTMenuDemo  awtMenuDemo = new AWTMenuDemo();     
      awtMenuDemo.showMenuDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMenuDemo(){
      //create a menu bar
      final MenuBar menuBar = new MenuBar();

      //create menus
      Menu fileMenu = new Menu("File");
      Menu editMenu = new Menu("Edit"); 
      final Menu aboutMenu = new Menu("About");

      //create menu items
      MenuItem newMenuItem = 
         new MenuItem("New",new MenuShortcut(KeyEvent.VK_N));
      newMenuItem.setActionCommand("New");

      MenuItem openMenuItem = new MenuItem("Open");
      openMenuItem.setActionCommand("Open");

      MenuItem saveMenuItem = new MenuItem("Save");
      saveMenuItem.setActionCommand("Save");

      MenuItem exitMenuItem = new MenuItem("Exit");
      exitMenuItem.setActionCommand("Exit");

      MenuItem cutMenuItem = new MenuItem("Cut");
      cutMenuItem.setActionCommand("Cut");

      MenuItem copyMenuItem = new MenuItem("Copy");
      copyMenuItem.setActionCommand("Copy");

      MenuItem pasteMenuItem = new MenuItem("Paste");
      pasteMenuItem.setActionCommand("Paste");
   
      MenuItemListener menuItemListener = new MenuItemListener();

      newMenuItem.addActionListener(menuItemListener);
      openMenuItem.addActionListener(menuItemListener);
      saveMenuItem.addActionListener(menuItemListener);
      exitMenuItem.addActionListener(menuItemListener);
      cutMenuItem.addActionListener(menuItemListener);
      copyMenuItem.addActionListener(menuItemListener);
      pasteMenuItem.addActionListener(menuItemListener);

      final CheckboxMenuItem showWindowMenu = 
         new CheckboxMenuItem("Show About", true);
      showWindowMenu.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            if(showWindowMenu.getState()){
               menuBar.add(aboutMenu);
            }else{
               menuBar.remove(aboutMenu);
            }
         }
      });

      //add menu items to menus
      fileMenu.add(newMenuItem);
      fileMenu.add(openMenuItem);
      fileMenu.add(saveMenuItem);
      fileMenu.addSeparator();
      fileMenu.add(showWindowMenu);
      fileMenu.addSeparator();
      fileMenu.add(exitMenuItem);

      editMenu.add(cutMenuItem);
      editMenu.add(copyMenuItem);
      editMenu.add(pasteMenuItem);

      //add menu to menubar
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(aboutMenu);

      //add menubar to the frame
      mainFrame.setMenuBar(menuBar);
      mainFrame.setVisible(true);  
   }

   class MenuItemListener implements ActionListener {
      public void actionPerformed(ActionEvent e) {            
         statusLabel.setText(e.getActionCommand() 
            + " MenuItem clicked.");
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTMenuDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTMenuDemo

验证以下输出

AWT MenuItem 类

简介

MenuBar 类表示菜单中的实际项。菜单中的所有项都应派生自 MenuItem 类或其子类之一。默认情况下，它包含一个简单的带标签的菜单项。

类声明

以下是 **java.awt.MenuItem** 类的声明

public class MenuItem
   extends MenuComponent
      implements Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.MenuComponent

• java.lang.Object

MenuItem 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTMenuDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AWTMenuDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AWTMenuDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AWTMenuDemo  awtMenuDemo = new AWTMenuDemo();     
      awtMenuDemo.showMenuDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMenuDemo(){
      //create a menu bar
      final MenuBar menuBar = new MenuBar();

      //create menus
      Menu fileMenu = new Menu("File");
      Menu editMenu = new Menu("Edit"); 
      final Menu aboutMenu = new Menu("About");

      //create menu items
      MenuItem newMenuItem = 
         new MenuItem("New",new MenuShortcut(KeyEvent.VK_N));
      newMenuItem.setActionCommand("New");

      MenuItem openMenuItem = new MenuItem("Open");
      openMenuItem.setActionCommand("Open");

      MenuItem saveMenuItem = new MenuItem("Save");
      saveMenuItem.setActionCommand("Save");

      MenuItem exitMenuItem = new MenuItem("Exit");
      exitMenuItem.setActionCommand("Exit");

      MenuItem cutMenuItem = new MenuItem("Cut");
      cutMenuItem.setActionCommand("Cut");

      MenuItem copyMenuItem = new MenuItem("Copy");
      copyMenuItem.setActionCommand("Copy");

      MenuItem pasteMenuItem = new MenuItem("Paste");
      pasteMenuItem.setActionCommand("Paste");
   
      MenuItemListener menuItemListener = new MenuItemListener();

      newMenuItem.addActionListener(menuItemListener);
      openMenuItem.addActionListener(menuItemListener);
      saveMenuItem.addActionListener(menuItemListener);
      exitMenuItem.addActionListener(menuItemListener);
      cutMenuItem.addActionListener(menuItemListener);
      copyMenuItem.addActionListener(menuItemListener);
      pasteMenuItem.addActionListener(menuItemListener);

      final CheckboxMenuItem showWindowMenu = 
         new CheckboxMenuItem("Show About", true);
      showWindowMenu.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            if(showWindowMenu.getState()){
               menuBar.add(aboutMenu);
            }else{
               menuBar.remove(aboutMenu);
            }
         }
      });

      //add menu items to menus
      fileMenu.add(newMenuItem);
      fileMenu.add(openMenuItem);
      fileMenu.add(saveMenuItem);
      fileMenu.addSeparator();
      fileMenu.add(showWindowMenu);
      fileMenu.addSeparator();
      fileMenu.add(exitMenuItem);

      editMenu.add(cutMenuItem);
      editMenu.add(copyMenuItem);
      editMenu.add(pasteMenuItem);

      //add menu to menubar
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(aboutMenu);

      //add menubar to the frame
      mainFrame.setMenuBar(menuBar);
      mainFrame.setVisible(true);  
   }

   class MenuItemListener implements ActionListener {
      public void actionPerformed(ActionEvent e) {            
         statusLabel.setText(e.getActionCommand() 
            + " MenuItem clicked.");
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTMenuDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTMenuDemo

验证以下输出。（单击“文件”菜单。选择任何菜单项。）

AWT Menu 类

简介

Menu 类表示从菜单栏部署的下拉菜单组件。

类声明

以下是 **java.awt.Menu** 类的声明

public class Menu
   extends MenuItem
      implements MenuContainer, Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.MenuItem

• java.awt.MenuComponent

• java.lang.Object

Menu 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTMenuDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AWTMenuDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AWTMenuDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AWTMenuDemo  awtMenuDemo = new AWTMenuDemo();     
      awtMenuDemo.showMenuDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMenuDemo(){
      //create a menu bar
      final MenuBar menuBar = new MenuBar();

      //create menus
      Menu fileMenu = new Menu("File");
      Menu editMenu = new Menu("Edit"); 
      final Menu aboutMenu = new Menu("About");

      //create menu items
      MenuItem newMenuItem = 
         new MenuItem("New",new MenuShortcut(KeyEvent.VK_N));
      newMenuItem.setActionCommand("New");

      MenuItem openMenuItem = new MenuItem("Open");
      openMenuItem.setActionCommand("Open");

      MenuItem saveMenuItem = new MenuItem("Save");
      saveMenuItem.setActionCommand("Save");

      MenuItem exitMenuItem = new MenuItem("Exit");
      exitMenuItem.setActionCommand("Exit");

      MenuItem cutMenuItem = new MenuItem("Cut");
      cutMenuItem.setActionCommand("Cut");

      MenuItem copyMenuItem = new MenuItem("Copy");
      copyMenuItem.setActionCommand("Copy");

      MenuItem pasteMenuItem = new MenuItem("Paste");
      pasteMenuItem.setActionCommand("Paste");
   
      MenuItemListener menuItemListener = new MenuItemListener();

      newMenuItem.addActionListener(menuItemListener);
      openMenuItem.addActionListener(menuItemListener);
      saveMenuItem.addActionListener(menuItemListener);
      exitMenuItem.addActionListener(menuItemListener);
      cutMenuItem.addActionListener(menuItemListener);
      copyMenuItem.addActionListener(menuItemListener);
      pasteMenuItem.addActionListener(menuItemListener);

      final CheckboxMenuItem showWindowMenu = 
         new CheckboxMenuItem("Show About", true);
      showWindowMenu.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            if(showWindowMenu.getState()){
               menuBar.add(aboutMenu);
            }else{
               menuBar.remove(aboutMenu);
            }
         }
      });

      //add menu items to menus
      fileMenu.add(newMenuItem);
      fileMenu.add(openMenuItem);
      fileMenu.add(saveMenuItem);
      fileMenu.addSeparator();
      fileMenu.add(showWindowMenu);
      fileMenu.addSeparator();
      fileMenu.add(exitMenuItem);

      editMenu.add(cutMenuItem);
      editMenu.add(copyMenuItem);
      editMenu.add(pasteMenuItem);

      //add menu to menubar
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(aboutMenu);

      //add menubar to the frame
      mainFrame.setMenuBar(menuBar);
      mainFrame.setVisible(true);  
   }

   class MenuItemListener implements ActionListener {
      public void actionPerformed(ActionEvent e) {            
         statusLabel.setText(e.getActionCommand() 
            + " MenuItem clicked.");
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTMenuDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTMenuDemo

验证以下输出。（单击“文件”菜单。）

AWT CheckboxMenuItem 类

简介

CheckboxMenuItem 类表示可以包含在菜单中的复选框。选择菜单中的复选框会将控件的状态从 **on** 更改为 **off** 或从 **off** 更改为 **on**。

类声明

以下是 **java.awt.CheckboxMenuItem** 类的声明

public class CheckboxMenuItem
   extends MenuItem
      implements ItemSelectable, Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.MenuItem

• java.awt.MenuComponent

• java.lang.Object

CheckboxMenuItem 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTMenuDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AWTMenuDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AWTMenuDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AWTMenuDemo  awtMenuDemo = new AWTMenuDemo();     
      awtMenuDemo.showMenuDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showMenuDemo(){
      //create a menu bar
      final MenuBar menuBar = new MenuBar();

      //create menus
      Menu fileMenu = new Menu("File");
      Menu editMenu = new Menu("Edit"); 
      final Menu aboutMenu = new Menu("About");

      //create menu items
      MenuItem newMenuItem = 
         new MenuItem("New",new MenuShortcut(KeyEvent.VK_N));
      newMenuItem.setActionCommand("New");

      MenuItem openMenuItem = new MenuItem("Open");
      openMenuItem.setActionCommand("Open");

      MenuItem saveMenuItem = new MenuItem("Save");
      saveMenuItem.setActionCommand("Save");

      MenuItem exitMenuItem = new MenuItem("Exit");
      exitMenuItem.setActionCommand("Exit");

      MenuItem cutMenuItem = new MenuItem("Cut");
      cutMenuItem.setActionCommand("Cut");

      MenuItem copyMenuItem = new MenuItem("Copy");
      copyMenuItem.setActionCommand("Copy");

      MenuItem pasteMenuItem = new MenuItem("Paste");
      pasteMenuItem.setActionCommand("Paste");
   
      MenuItemListener menuItemListener = new MenuItemListener();

      newMenuItem.addActionListener(menuItemListener);
      openMenuItem.addActionListener(menuItemListener);
      saveMenuItem.addActionListener(menuItemListener);
      exitMenuItem.addActionListener(menuItemListener);
      cutMenuItem.addActionListener(menuItemListener);
      copyMenuItem.addActionListener(menuItemListener);
      pasteMenuItem.addActionListener(menuItemListener);

      final CheckboxMenuItem showWindowMenu = 
         new CheckboxMenuItem("Show About", true);
      showWindowMenu.addItemListener(new ItemListener() {
         public void itemStateChanged(ItemEvent e) {
            if(showWindowMenu.getState()){
               menuBar.add(aboutMenu);
            }else{
               menuBar.remove(aboutMenu);
            }
         }
      });

      //add menu items to menus
      fileMenu.add(newMenuItem);
      fileMenu.add(openMenuItem);
      fileMenu.add(saveMenuItem);
      fileMenu.addSeparator();
      fileMenu.add(showWindowMenu);
      fileMenu.addSeparator();
      fileMenu.add(exitMenuItem);

      editMenu.add(cutMenuItem);
      editMenu.add(copyMenuItem);
      editMenu.add(pasteMenuItem);

      //add menu to menubar
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(aboutMenu);

      //add menubar to the frame
      mainFrame.setMenuBar(menuBar);
      mainFrame.setVisible(true);  
   }

   class MenuItemListener implements ActionListener {
      public void actionPerformed(ActionEvent e) {            
         statusLabel.setText(e.getActionCommand() 
            + " MenuItem clicked.");
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTMenuDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTMenuDemo

验证以下输出。（单击“文件”菜单。取消选择“显示关于”菜单项。）

AWT PopupMenu 类

简介

弹出菜单表示一个菜单，可以在组件内的指定位置动态弹出。

类声明

以下是 **java.awt.PopupMenu** 类的声明

public class CheckboxMenuItem
   extends MenuItem
      implements ItemSelectable, Accessible

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.MenuItem

• java.awt.MenuComponent

• java.lang.Object

PopupMenu 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTMenuDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;

public class AWTMenuDemo {
   private Frame mainFrame;
   private Label headerLabel;
   private Label statusLabel;
   private Panel controlPanel;

   public AWTMenuDemo(){
      prepareGUI();
   }

   public static void main(String[] args){
      AWTMenuDemo  awtMenuDemo = new AWTMenuDemo();     
      awtMenuDemo.showPopupMenuDemo();
   }

   private void prepareGUI(){
      mainFrame = new Frame("Java AWT Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      headerLabel = new Label();
      headerLabel.setAlignment(Label.CENTER);
      statusLabel = new Label();        
      statusLabel.setAlignment(Label.CENTER);
      statusLabel.setSize(350,100);

      controlPanel = new Panel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }

   private void showPopupMenuDemo(){
      final PopupMenu editMenu = new PopupMenu("Edit"); 

      MenuItem cutMenuItem = new MenuItem("Cut");
      cutMenuItem.setActionCommand("Cut");

      MenuItem copyMenuItem = new MenuItem("Copy");
      copyMenuItem.setActionCommand("Copy");

      MenuItem pasteMenuItem = new MenuItem("Paste");
      pasteMenuItem.setActionCommand("Paste");

      MenuItemListener menuItemListener = new MenuItemListener();

      cutMenuItem.addActionListener(menuItemListener);
      copyMenuItem.addActionListener(menuItemListener);
      pasteMenuItem.addActionListener(menuItemListener);

      editMenu.add(cutMenuItem);
      editMenu.add(copyMenuItem);
      editMenu.add(pasteMenuItem);   
      
      controlPanel.addMouseListener(new MouseAdapter() {
         public void mouseClicked(MouseEvent e) {            
               editMenu.show(controlPanel, e.getX(), e.getY());
         }               
      });
      controlPanel.add(editMenu); 

      mainFrame.setVisible(true);
   }
	
   class MenuItemListener implements ActionListener {
      public void actionPerformed(ActionEvent e) {            
         statusLabel.setText(e.getActionCommand() 
            + " MenuItem clicked.");
      }    
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTMenuDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTMenuDemo

验证以下输出。（单击屏幕中间。）

AWT 图形类

图形控件允许应用程序在组件或图像上绘制。

AWT Graphics 类

简介

Graphics 类是所有图形上下文的抽象超类，它允许应用程序绘制到可以在各种设备上实现的组件上，或者绘制到屏幕外图像上。

Graphics 对象封装了 Java 支持的基本渲染操作所需的所有状态信息。状态信息包括以下属性。

• 要绘制的 Component 对象。

• 用于渲染和裁剪坐标的平移原点。

• 当前剪辑。

• 当前颜色。

• 当前字体。

• 当前逻辑像素操作函数。

• 当前 XOR 交替颜色

类声明

以下是 **java.awt.Graphics** 类的声明

public abstract class Graphics
   extends Object

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Graphics 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      g.setColor(Color.GRAY);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 150);      
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Graphics2D 类

简介

Graphics2D 类扩展了 Graphics 类，以提供对几何图形、坐标转换、颜色管理和文本布局的更精细的控制。

类声明

以下是 **java.awt.Graphics2D** 类的声明

public abstract class Graphics2D
   extends Graphics

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Graphics2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Graphics2D g2 = (Graphics2D)g;
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
         RenderingHints.VALUE_ANTIALIAS_ON);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g2.drawString("Welcome to TutorialsPoint", 50, 70); 
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Arc2D 类

简介

Arc2D 类是所有存储由框架矩形、起始角、角度范围（弧长）和闭合类型（OPEN、CHORD 或 PIE）定义的二维弧的对象的超类。

类声明

以下是 **java.awt.Arc2D** 类的声明

public abstract class Arc2D
   extends RectangularShape

字段

以下是 **java.awt.geom.Arc2D** 类的字段

• **static int CHORD** -- 用于通过绘制从弧段开始到弧段结束的直线段来闭合弧的闭合类型。

• **static int OPEN** -- 用于没有连接弧段两端的路径段的开放弧的闭合类型。

• **static int PIE** -- 用于通过绘制从弧段开始到完整椭圆中心的直线段，以及从该点到弧段结束的直线段来闭合弧的闭合类型。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.geom.RectangularShape

• java.lang.Object

Arc2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Arc2D.Float arc = new Arc2D.Float(Arc2D.PIE);
      arc.setFrame(70, 200, 150, 150);
      arc.setAngleStart(0);
      arc.setAngleExtent(145);
      Graphics2D g2 = (Graphics2D) g; 
      g2.setColor(Color.gray);
      g2.draw(arc);
      g2.setColor(Color.red);
      g2.fill(arc);
      g2.setColor(Color.black);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("Arc2D.PIE", 100, 120); 
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtGraphicsDemo

验证以下输出

AWT CubicCurve2D 类

简介

CubicCurve2D 类在 (x,y) 坐标空间中指定了一个三次参数曲线段。

类声明

以下是 **java.awt.geom.CubicCurve2D** 类的声明

public abstract class CubicCurve2D
   extends Object
      implements Shape, Cloneable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

CubicCurve2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      CubicCurve2D shape = new CubicCurve2D.Float();
      shape.setCurve(250F,250F,20F,90F,140F,100F,350F,330F);       
      Graphics2D g2 = (Graphics2D) g; 
      g2.draw (shape);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("CubicCurve2D.Curve", 100, 120);
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Ellipse2D 类

简介

Ellipse2D 类表示由一个外接矩形定义的椭圆。

类声明

以下是 java.awt.geom.Ellipse2D 类的声明

public abstract class Ellipse2D
   extends RectangularShape

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Ellipse2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Ellipse2D shape = new Ellipse2D.Float();
      shape.setFrame(100, 150, 200,100);
      Graphics2D g2 = (Graphics2D) g; 
      g2.draw (shape);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("Ellipse2D.Oval", 100, 120); 
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Rectangle2D 类

简介

Rectangle2D 类表示由位置 (x,y) 和尺寸 (w x h) 定义的矩形。

类声明

以下是 java.awt.geom.Rectangle2D 类的声明

public abstract class Rectangle2D
   extends RectangularShape

字段

以下是 **java.awt.geom.Arc2D** 类的字段

• static int OUT_BOTTOM -- 指示点位于此 Rectangle2D 下方的位掩码。

• static int OUT_LEFT -- 指示点位于此 Rectangle2D 左侧的位掩码。

• static int OUT_RIGHT -- 指示点位于此 Rectangle2D 右侧的位掩码。

• static int OUT_TOP -- 指示点位于此 Rectangle2D 上方的位掩码。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.awt.geom.RectangularShape

• java.lang.Object

Ellipse2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Rectangle2D shape = new Rectangle2D.Float();
      shape.setFrame(100, 150, 200,100);
      Graphics2D g2 = (Graphics2D) g; 
      g2.draw (shape);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("Rectangle2D.Rectangle", 100, 120);
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT QuadCurve2D 类

简介

QuadCurve2D 类表示 (x,y) 坐标空间中的二次参数曲线段。

类声明

以下是 java.awt.geom.QuadCurve2D 类的声明

public abstract class QuadCurve2D
   extends Object
      implements Shape, Cloneable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

QuadCurve2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      QuadCurve2D shape = new QuadCurve2D.Double();
      shape.setCurve(250D,250D,100D,100D,200D,150D);  
      Graphics2D g2 = (Graphics2D) g; 
      g2.draw (shape);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("QuadCurve2D.Curve", 100, 120);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Line2D 类

简介

Line2D 类表示 (x,y) 坐标空间中的线段。

类声明

以下是 java.awt.geom.Line2D 类的声明

public abstract class Line2D
   extends Object
      implements Shape, Cloneable

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Line2D 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Line2D shape = new Line2D.Double();
      shape.setLine(250D,250D,150D,150D);  
      Graphics2D g2 = (Graphics2D) g; 
      g2.draw (shape);
      Font font = new Font("Serif", Font.PLAIN, 24);
      g2.setFont(font);
      g.drawString("Welcome to TutorialsPoint", 50, 70);
      g2.drawString("Line2D.Line", 100, 120);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Font 类

简介

Font 类表示字体，字体用于以可见方式呈现文本。

类声明

以下是 java.awt.Font 类的声明

public class Font
   extends Object
      implements Serializable

字段

以下是 **java.awt.geom.Arc2D** 类的字段

• static int BOLD -- 粗体样式常量。

• static int CENTER_BASELINE -- 在布局文本时，在汉语、日语和韩语等表意文字中使用的基线。

• static String DIALOG -- 逻辑字体“Dialog”的规范系列名称的字符串常量。

• static String DIALOG_INPUT -- “DialogInput” 逻辑字体的规范族名称的字符串常量。

• static int HANGING_BASELINE -- 在排版文本时，天城体和类似文字使用的基线。

• static int ITALIC -- 斜体样式常量。

• static int LAYOUT_LEFT_TO_RIGHT -- 传递给 layoutGlyphVector 的一个标志，指示文本根据双向分析结果是从左到右的。

• static int LAYOUT_NO_LIMIT_CONTEXT -- 传递给 layoutGlyphVector 的一个标志，指示不应检查字符数组中指定限制之后的文本。

• static int LAYOUT_NO_START_CONTEXT -- 传递给 layoutGlyphVector 的一个标志，指示不应检查字符数组中指定起始位置之前的文本。

• static int LAYOUT_RIGHT_TO_LEFT -- 传递给 layoutGlyphVector 的一个标志，指示文本根据双向分析结果是从右到左的。

• static String MONOSPACED -- “Monospaced” 逻辑字体的规范族名称的字符串常量。

• protected String name -- 此 Font 的逻辑名称，传递给构造函数。

• static int PLAIN -- 普通样式常量。

• protected float pointSize -- 此 Font 的点大小（浮点数）。

• static int ROMAN_BASELINE -- 大多数罗马文字在排版文本时使用的基线。

• static String SANS_SERIF -- “SansSerif” 逻辑字体的规范族名称的字符串常量。

• static String SERIF -- “Serif” 逻辑字体的规范族名称的字符串常量。

• protected int size -- 此 Font 的点大小（四舍五入为整数）。

• protected int style -- 此 Font 的样式，传递给构造函数。

• static int TRUETYPE_FONT -- 识别类型为 TRUETYPE 的字体资源。

• static int TYPE1_FONT -- 识别类型为 TYPE1 的字体资源。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Font 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Graphics2D g2 = (Graphics2D)g;        
      Font plainFont = new Font("Serif", Font.PLAIN, 24);        
      g2.setFont(plainFont);
      g2.drawString("Welcome to TutorialsPoint", 50, 70); 
      Font italicFont = new Font("Serif", Font.ITALIC, 24);        
      g2.setFont(italicFont);
      g2.drawString("Welcome to TutorialsPoint", 50, 120); 
      Font boldFont = new Font("Serif", Font.BOLD, 24);        
      g2.setFont(boldFont);
      g2.drawString("Welcome to TutorialsPoint", 50, 170); 
      Font boldItalicFont = new Font("Serif", Font.BOLD+Font.ITALIC, 24);        
      g2.setFont(boldItalicFont);
      g2.drawString("Welcome to TutorialsPoint", 50, 220); 
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT Color 类

简介

Color 类以默认的 sRGB 颜色空间或由 ColorSpace 标识的任意颜色空间中的颜色来表示颜色。

类声明

以下是 **java.awt.Color** 类的声明

public class Color
   extends Object
      implements Paint, Serializable

字段

以下是 **java.awt.geom.Arc2D** 类的字段

• static Color black -- 黑色。

• static Color BLACK -- 黑色。

• static Color blue -- 蓝色。

• static Color BLUE -- 蓝色。

• static Color cyan -- 青色。

• static Color CYAN -- 青色。

• static Color DARK_GRAY -- 深灰色。

• static Color darkGray -- 深灰色。

• static Color gray -- 灰色。

• static Color GRAY -- 灰色。

• static Color green -- 绿色。

• static Color GREEN -- 绿色。

• static Color LIGHT_GRAY -- 浅灰色。

• static Color lightGray -- 浅灰色。

• static Color magenta -- 品红色。

• static Color MAGENTA -- 品红色。

• static Color orange -- 橙色。

• static Color ORANGE -- 橙色。

• static Color pink -- 粉红色。

• static Color PINK -- 粉红色。

• static Color red -- 红色。

• static Color RED -- 红色。

• static Color white -- 白色。

• static Color WHITE -- 白色。

• static Color yellow -- 黄色。

• static Color YELLOW -- 黄色。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

Color 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Graphics2D g2 = (Graphics2D)g;        
      Font plainFont = new Font("Serif", Font.PLAIN, 24);        
      g2.setFont(plainFont);
      g2.setColor(Color.red);
      g2.drawString("Welcome to TutorialsPoint", 50, 70); 
      g2.setColor(Color.GRAY);
      g2.drawString("Welcome to TutorialsPoint", 50, 120);  
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AWTGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AWTGraphicsDemo

验证以下输出

AWT BasicStroke 类

简介

BasicStroke 类以默认的 sRGB 颜色空间或由 ColorSpace 标识的任意颜色空间中的颜色来表示颜色。

类声明

以下是java.awt.BasicStroke类的声明

public class BasicStroke
   extends Object
      implements Stroke

字段

以下是 **java.awt.geom.Arc2D** 类的字段

• static int CAP_BUTT -- 以不添加任何装饰的方式结束未闭合的子路径和虚线段。

• static int CAP_ROUND -- 以圆形装饰结束未闭合的子路径和虚线段，该装饰的半径等于笔宽的一半。

• static int CAP_SQUARE -- 以正方形投影结束未闭合的子路径和虚线段，该投影超出线段末端，延伸距离等于线宽的一半。

• static int JOIN_BEVEL -- 通过用直线段连接其宽轮廓的外角来连接路径段。

• static int JOIN_MITER -- 通过扩展其外部边缘直到它们相遇来连接路径段。

• static int JOIN_ROUND -- 通过以线宽一半的半径圆角连接路径段。

类构造函数

类方法

继承的方法

此类继承自以下类的方法

• java.lang.Object

BasicStroke 示例

使用您选择的任何编辑器创建以下 Java 程序，例如在 **D:/ > AWT > com > tutorialspoint > gui >** 中

AWTGraphicsDemo.java

package com.tutorialspoint.gui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class AWTGraphicsDemo extends Frame {
       
   public AWTGraphicsDemo(){
      super("Java AWT Examples");
      prepareGUI();
   }

   public static void main(String[] args){
      AWTGraphicsDemo  awtGraphicsDemo = new AWTGraphicsDemo();  
      awtGraphicsDemo.setVisible(true);
   }

   private void prepareGUI(){
      setSize(400,400);
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      }); 
   }    

   @Override
   public void paint(Graphics g) {
      Graphics2D g2 = (Graphics2D)g;        
      g2.setStroke(new BasicStroke(3.0f));
      g2.setPaint(Color.blue);

      Rectangle2D shape = new Rectangle2D.Float();
      shape.setFrame(100, 150, 200,100);
      g2.draw(shape);

      Rectangle2D shape1 = new Rectangle2D.Float();
      shape1.setFrame(110, 160, 180,80);
      g2.setStroke(new BasicStroke(1.0f));
   
      g2.draw(shape1);
      Font plainFont = new Font("Serif", Font.PLAIN, 24);        
      g2.setFont(plainFont);
      g2.setColor(Color.DARK_GRAY);
      g2.drawString("TutorialsPoint", 130, 200);
   }
}

使用命令提示符编译程序。转到 **D:/ > AWT** 并键入以下命令。

D:\AWT>javac com\tutorialspoint\gui\AwtGraphicsDemo.java

如果没有任何错误，则表示编译成功。使用以下命令运行程序。

D:\AWT>java com.tutorialspoint.gui.AwtGraphicsDemo

验证以下输出