JAVA中AWT基本组件及其使用方法(一)

JAVA中AWT基本组件及其使用方法(一)(2007-07-24 23:12:32)转载▼标签： 水之后java编程awt 分类： JAVA-初级 
 一、按钮：
/**
 * 按钮(Button)是JAVA图形用户界面的基本组件之一,它有两个构造方法:
 * public Button()
 * public Button(String lable)
 * 其中第一种方法构造一个不带标签的按钮，第二种方法构造一个带标签的按钮。
 * 当用户用鼠标单击按钮时，AWT事件处理系统将向按钮发送一个ActionEvent事件对象。如果应用程序需要对此作出反应，那么就

需要为注册事件监听程序并实现ActionListener接口。
 * 下面的程序是一个使用按钮的例子。
 * @author ifwater
 */

import java.awt.*;
import java.awt.event.*;
class ButtonExample extends WindowAdapter implements ActionListener{
    //定义基本组件
    Frame f;
    Button b;
    TextField tf;
    int tag=0;

    //初始化按钮组件
    public static void main(String args[]) {
        ButtonExample be=new ButtonExample();
        be.go();
    }

    public void go(){
    //初始化其他组件，并且通过ActionListener()方法为按钮注册监听程序
    f=new Frame("Button Example");
    b=new Button("Sample");
    b.addActionListener(this);
    f.add(tf,"South");

    tf=new TextField();
    f.add(tf,"Center");

    f.addWindowListener(this);
    f.setSize(300,500);
    f.setVisible(true);
    }

    //实现ActionListener接口中的actionPerformed()方法
    public void actionPerformed(ActionEvent e){
        String s1="You hava Pressed the Button";
        String s2="You do another time";

    if(tag==0){
        tf.setText(s1);
        tag=1;
    }else {
        tf.setText(s2);
        tag=0;
    }
    }

    public void windowClosing(WindowEvent e){
            System.exit(0);
    }
}

 

二、复选框

/**
 * 复选框(Checkbox)是一个带标签的小方框，具有“开”和“关”两种状态
 * 用户对复选框的操作将引发ItemEvent事件，该事件需要由实现ItemEvent接口的类的处理
 * 在ItemEvent类中定义了getStateChange()方法，通过该方法可以判断用户对复选框所执行的操作是“开”还是“关”，其返回值为常

量Item.DESELECTED或Item.SELECTED
 * ItemEvent类中还定义了getItem()方法，该方法返回值为一字符串，表示用户操作所涉及的复选框的标签内容
 * 复选框的有三种基本的构造方法：
 * (1)public Checkbox() 构造一个不带标签、初始状态为“关”的复选框
 * (2)public Checkbox(String label)构造一个带标签、初始状态为“关”的复选框
 * (3)public Checkbox(String label,boolean state)构造一个带标签，其初始状态由boolean型变量state决定
 * @author ifwater
 */

import java.awt.*;
import java.awt.event.*;
class CheckboxExample extends WindowAdapter implements ItemListener{
 
 //定义一个框架f、面板p、复选框one、复选框two、复选框three和文本框TextField
    Frame f;
    Panel p;
    Checkbox one,two,three;
    TextField tf;
  
    public static void main(String args[]){
    
     //创建一个CheckboxExample类ce，它的方法为go()
     CheckboxExample ce = CheckboxExample();
     ce.go();
    }

 public void go(){
 
  //前面对f和p进行了定义，现在通过new对其进行初始化
     f = new Frame("Checkbox Example");
     p = new Panel();
    
     //通过初始化，创建三个复选框
     one = new Checkbox("one");
     two = new Checkbox("two");
     three = new Checkbox("three");
    
     //对三个复选框注册事件监听程序
     one.addItemListener(this);
     two.addItemListener(this);
     three.addItemListener(this);
    
     //使用add方法，将三个复选框加到f和p对象中
     p.add(one);
     p.add(two);
     p.add(three);
     f.add(tf,"South");
    
     //注册事件监听程序，设定窗口f的大小，并把f以及它包含的组件显示出来对用户可见
     f.addWindowListener(this);
     f.setSize(300, 500);
     f.setVisible(true);
    }
  
    //实现ItemListener接口中的itemStateChanged()方法
    public void itemStateChanged(ItemEvent e){
     String state = "deselected";
     String st;
    
     if(e.getStateChange() == ItemEvent.SELECTED){
      state = "selected";
     }
     st = e.getItem() + " " + state;
     tf.setText(st);
    }
  
    //覆盖WindowAdapter类中的windowClosing（）方法
    public void windowClosing(WindowEvent e){
     //结束程序运行
     System.exit(0);
    }
}

三、单选框

/**
 * 单选按钮时复选框组中特殊的构造方法：
 * (1) public Checkbox(String label,boolean state,CheckboxGroup group)
 * (2) public Checkbox(String label,CheckboxGroup group,boolean state)
 * 在这两种构造方法中均使用了CheckboxGroup类型的参数，通过这两种构造方法，可以创建出多个从属于同一个复选框组

(CheckboxGroup group)的、带标签的复选框
 * 复选框的初始状态有boolean型变量state指定
 * @author ifwater
 */

import java.awt.*;
import java.awt.event.*;
class CheckboxGroupExample extends WindowAdapter implements ItemListener{

    //各个框架的定义
    Frame f;
    Panel p;
    CheckboxGroup cbg;
    Checkbox one,two,three;
    TextField tf;

    public static void main(String args[]){
        CheckboxGroupExample ce = new CheckboxGroupExample();
        ce.go();
    }
    public void go(){

    //通过对已经定义的f、g进行初始化，创建f、g
    f = new Frame("CheckboxGroup Example");
    p = new Panel();

    //通过对已经定义复选框进行初始化，创建三个从属于同一个组的复选框
    cbg = new CheckboxGroup();
    one = new Checkbox("One",cbg,false);
    two = new Checkbox("Two",cbg,false);
    three = new Checkbox("Three",cbg,true);

    //注册事件监听程序
    one.addItemListener(this);
    two.addItemListener(this);
    three.addItemListener(this);

    p.add(one);
    p.add(two);
    p.add(three);
    f.add(tf,"South");

    //注册事件监听程序
    f.addWindowListener(this);
    f.setSize(300,500);
    f.setVisible(true);
    }

    //实现ItemListener接口中的itemStateChanged()方法
    public void itemStateChanged(ItemEvent e){
        String st;
        st = e.getItem() + "selected";
        tf.setText(st);
    }

    //覆盖WindowAdapter类中的windowClosing()方法
    public void windowClosing(WindowEvent e){
        System.exit(0);
    }
}

四、选择框

/**
 * 选择框(Choice)是一个下拉式菜单，其构造方法为：public Choice()
 *刚刚构造出来的选择框中并没有实际内容，需要使用addItem()方法为其添加新的选择项
 * @author ifwater
 */

import java.awt.*;
class ChoiceExample{
    Frame f;
    Choice c;
    Label l;

    public static void main(String arg[]){
        ChoiceExample ce = new ChoiceExample();
        ce.go();
    }

    void go(){
    f = new Frame();
    f.setLayout(new FlowLayout());
    l =new Label("your choice:");
    f.add(l);
    c = new Choice();
    c.addItem("First");
    c.addItem("Second");
    c.addItem("Third");
    f.add(c);

    f.setSize(250,160);
    f.setVisible(true);
    }
}

五、画布

/**
 * 画布(Canvas)是一块空白区域，可用于绘画、输出文本信息或者接收键盘和鼠标输入，其构造方法为：
 * public Canvas()
 * 画布可对各类事件进行监听，通常需要在程序中实现KeyListener,MouseMotionListener和MouseListener等接口，以便使画布能

够对用户的输入作出响应
 * 为了在画布中接收键盘事件，必须调用Canvas类的requestFocus()方法，否则，画布有可能接收不到属于它的键盘事件；那些键

盘事件可能被其他组件接收，也可能全部丢失
 * 下面的程序创建了一个画布并实现了KeyListener和MouseListener接口
 * @author ifwater
 */

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

public class MyCanvas implements KeyListener,MouseListener{
    Canvas c;
    String s="";
    TextField t;

    public static void main(String args[]){
      Frame f = new Frame("Canvas");
      MyCanvas mc = new MyCanvas();
      mc.c = new Canvas();
      mc.t = new TextField();
      f.add("South",mc,t);
      f.add("Center",mc,c);
      f.setSize(300.500);
      mc.c.addMouseListener(mc);
      mc.c.addKeyListener(mc);
      f.setVisible(true);
    }
  
    //实现KeyListener接口中的方法
    public void keyTyped(KeyEvent ev){
      t.setText("keyTyped");
      s += ev.getKeyChar();
    
      //将用户键入的字符写到画布上
      c.getGraphics().drawString(s,0,20);
    }
  
    public void keyPressed(KeyEvent ev){ }
  
    public void keyReleased(KeyEvent ev){
      t.setText("keyReleased");
    }
  
    //实现MouseListener接口中的方法
     public void MouseClicked(MouseEvent ev){
       t.setText("mouseClicked");
       //强制画布获取输入焦点
       c.requestFocus();
     }
   
     public void MousePressed(MouseEvent ev){
       t.setText("mousePressed");
     }
   
     public void MouseEntered(MouseEvent ev){
       t.setText("MouseEntered");
     }
   
     public void MouseExited(MouseEvent ev){
       t.setText("MouseExited");
     }
}

六、标签

/**
 * 标签（Label）对象通常只用于显示提示性的文本信息，其构造方法有三种形式：
 * (1) public Label() 构造一个空标签
 * (2) public Label(String text) 构造一个以左对齐方式显示指定字符串的标签
 * (3) public Label(String text,int alignment) 构造一个显示指定字符串的标签，字符串对齐方式由int型参数alignment指定

（其值可为Label.LEFT,Label.RIGHT和Label.CENTER;分别为左对齐、右对齐和居中）
 * 在程序中，可以使用setText(String text)方法修改显示在标签上的字符串，但是在程序运行过程中，用户不能对标签内容进行

修改
 * @author ifwater
 *
 */

import java.awt.*;
public class LabelExample {
 static public void main(String[]args){
  Frame f;
  Label l1,l2,l3;
 
  f = new Frame("Label Example");
  f.setLayout(new GridLayout(3,1,30,30));
  l1 = new Label("Hello,this is Label1");
  l2 = new Label("Hello,this is Label2");
  l3 = new Label("Hello,this is Label3");
  f.add(l1);
  f.add(l2);
  f.add(l3);
  f.setSize(300, 200);
  f.setVisible(true);
 }
}

七、文本域

文本域（TextField）是一个单行的文本输入框，它有四种构造方法：

(1) public TextField() 构造一个空文本域
(2) public TextField(String text) 构造一个显示指定字符串的文本域，String型参数text指定要显示的初始字符串
(3) public TextField(int columns) 构造一个具有指定列数的空文本域，int型参数指定文本域的列数
(4) public TextField(String text，int columns) 构造一个具有指定列数、显示指定初始字符串的文本域，String型参数text指

定要显示的初始字符串，int型参数指定文本域的列数
由于在文本域中只允许输入一行文本内容，因此当用户按Enter或Return键时，将会引发ActionEvent事件，对此，可用实现了

ActionListener接口的类通过actionPerformed()方法进行处理。除此之外，也可以根据需要为文本域注册其他事件监听程序

八、文本区

/**
 * 文本区(TextArea)是一个多行多列的文本输入框，它有五种构造方法：
 * (1) public TextArea() 构造一个有水平和垂直滚动杠的空文本区
 * (2) public TextArea(String text) 构造一个有水平和垂直滚动杠并显示初始文本内容的文本区
 * (3) public TextArea(int rows,int columns) 构造一个有水平和垂直滚动杠并具有指定行数和列数的文本区
 * (4) public TextArea(String text,int rows,int columns) 构造一个有水平和垂直滚动杠、具有指定行数和列数并显示初始文

本内容的文本区
 * (5) public TextArea(String text,int rows,int columns,int scrollbars) 构造一个具有指定行数、列数及滚动杆并显示初始

文本内容的文本区
 * 其中，String型参数指定要显示的初始文本的内通；int型参数rows和columns分别指定文本区行数和列数，int型参数scrollbars

指定要显示的滚动杆，它有四种可能的取值
 * 1) SCROLLBARS_BOTH 同时显示水平和垂直滚动杆
 * 2) SCROLLBARS_VERTICAL_ONLY 只显示垂直滚动杆
 * 3) SCROLLBARS_HORIZONTAL_ONLY 只显示水平滚动杆
 * 4) SCROLLBARS_NONE 两个滚动杆都不显示
 * 可以使用setEditable(boolean)方法将文本区设置为不可编辑或可编辑的状态。
 * 由于文本区中的可输入的文本是多行的，用户按Enter或Return键的结果只是向缓冲区输入一个字符，而不能表示输入结束
 * 因此，输入完成时，通常要在文本区旁放置一个Apply或Commit之类的按钮
 * 下面的程序创建了一个文本域和两个文本区，通过事件处理程序，用户在文本域和第一个文本区上进行操作所引发的事件名称会

显示在第二个文本区中
 * @ author ifwater
 */

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

public class TextAreaExample implements ActionListener,TextListener{
    Frame f;
    TextField tf1;
    TextArea ta1,ta2;

    static public void main(String args[]){
      TextExample te = new TextExample();
      te.go();
    }

    public void go(){
      f = new Frame("Text Example");
      f.setLayout(new FlowLayout());

      tf1 = new TextField("Init",20);
      tf1.addActionListener(this);
      tf1.addTextListener(this);

      ta1 = new TextArea("Initial",4,30);
      ta1.addTextListener(this);
      ta2 = new TextArea("Only horizontal",4,30,TextArea.SCROLLBARS_HORIZONTAL_ONLY);

      f.add(tf1);
      f.add(ta1);
      f.add(ta2);
      f.setSize(300,300);
      f.setVisible(true);
    }
  
    public void actionPerformed(ActionEvent e){
      ta2.append("\nActionPerformed");
    }
  
    public void TextValueChanged(TextEvent e){
      ta2.append("\nTextValueChanged");
    }

}

九、文本组件

    虽然TextArea和TextField是两个不同的类，但是如果查阅名为TextComponet类的文档，就会发现这个类定义了很多TextArea类

和TextField类共有的方法，这是因为该类是TextArea和TextField两个类的父类。
    在TextComponet类中定义的主要方法有：
    (1) getSelectedText() 从文本组件中提取被选中的文本内容
    (2) getText() 从文本组件中提取所有的内容
    (3) select(int,int) 在文本组件中选中部分的内容
    (4) selectAll() 在文本组件中选中所有内容
    (5) setEditable(boolean) 设置为可编辑或不可编辑状态
    (6) setText(String) 设置文本组件中的内容

十、列表

/**
 * 列表(List)是可供用户进行选择的一系列可选项，它可支持单项选择和多项选择。列表有三种构造方法：
 * (1) public List() 构造一个单选列表
 * (2) public List(int rows) 构造一个显示指定项数的单选列表，其中int型参数指定要显示的项数
 * (3) public List(int rows,boolean multipleMode)构造一个显示指定项数的列表，其中int型参数指定要显示的项数，boolean

型参数指定该列表示单选(false)列表还是多选(true)列表
 * 下面的程序构造了一个显示5个可选项的单选列表，通过ItemListener接口中的itemStateChanged()方法，用户的选择被显示在窗

口底部
 * @author ifwater
 */

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

public class ListExample extends Frame implements ItemListener{
    Panel p;
    List theList;
    TextField tf;

    ListExample(String s){ super (s);}

    public static void main(String args[]){
      ListExample le = new ListExample("List Example");
      le.init();
    }

    void init(){
      //构造一个显示5个可选项的单选列表
      theList = new List(5,false);
      theList.add("Monday");
      theList.add("Tuesday");
      theList.add("Wednesday");
      theList.add("Thursday");
      theList.add("Friday");
      theList.add("Saturday");
      theList.add("Sunday");

      //注册ItemEvent事件监听程序
      theList.addItemListener(this);
    
      p= new Panel();
      p.add(theList);
      add(p,"Center");
      tf = new TextField();
      add(tf,"South");
      setSize(300,200);
      setVisible(true);
    }
  
    //实现ItemListener接口中的方法
    public void itemStateChanged(ItemEvent e){
      tf.setText(thisList.getSelectedItem());
    }
}

 
十一、框架

    框架是一种带标题和边框，并且能够改变大小的窗口，它有两种构造方法：
    (1) Frame() 构造一个没有标题的框架
    (2) Frame（String）构造一个显示指定标题的框架
    框架的默认布局管理器是BorderLayout。框架的大小可以用setSize()方法设定，然而更常用的方法是使用pack(组建ack()能够使用布局管理器进行计算，得出一个适当的框架大小，使得框架以缩紧形式包容其中的组件。
    框架可以对多种事件进行监听。框架能够作为单独窗口使用。当用户从窗口控制菜单中选择关闭窗口时，会引发WindowEvent事件，可以用WindowListener接口中的WindowClosing()方法对其进行处理。
    注意：不要试图在框架中直接监听键盘事件。尽管在画布组件和标签组件中适用的requestFocus()方法在框架中有时也会起作用，但并不可靠。因此如果要监听键盘事件，最好还是在框架中加入画布或面板之类的组件，然后通过这类组件对键盘事件进行监听。

十二、面板

    画板通常只作为纯粹的容器来使用，它不能象框架、窗口和对话框一样独立存在。面板构造方法有两种：
    (1) Panel() 构造一个使用默认布局管理器(FlowLayout)的面板
    (2) Panel(LayoutManager) 构造一个使用指定布局管理器的面板
    在面板中也可以对多种事件进行监听。与画布类似，当处理键盘事件时，需要事先取得焦点。

十三、对话框

/**
 * 对话框(Dialog)是与框架类似的可移动窗口，它与框架的区别在于具有较少的修饰并且能够设置为“模式(modal)”窗口——在该窗口被关闭之前，其他窗口无法接收任何形式的输入。对话框有四种构造方法：
 * (1) public Dialog(Frame parent) 构造一个没有标题的对话框
 * (2) public Dialog(Frame parent,boolean modal) 构造一个没有标题的对话框，boolean型参数指定对话框是否为模式窗口
 * (3) public Dialog(Frame parent,String title) 构造一个显示制定标题的对话框
 * (4) public Dialog(Frame parent,Sting title,boolean modal) 构造一个显示指定标题的对话框，boolean型参数指定对话框是否为模式窗口
 * 刚刚创建的对话框是不可见的，需要调用setVisible(true)方法才能将其显示出来。
 * 下面的程序构造了一个对话框，当用户单击框架中的按钮时，对话框将被显示出来
 * @author ifwater
 */

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

public class DialogExample
    extends WindowAdapter
      implements ActionListener{
    Frame f;
    Button b;
    Dialog d;
  
    static public void main(String args[]){
      DialogExample de = new DialogExample();
      de.go();
    }
  
    public void go(){
      f = new Frame("Dialog Example");
      b = new Button("Show Dialog");
      b.addActionListener(this);
      f.add("South",b);
    
      d = new Dialog(f,"Dialog",true);
      d.add("Center",new Label("Hello,I'm a Dialog"));
      d.pack();
      d.addWindowListener(this);
      f.setSize(250,150);
      f.setVisible(true);
    }
  
    public void actionPerformed(ActionEvent e){
      //显示对话框
      d.setVisible(true);
    }
  
    public void windowClosing(ActionEvent e){
      //隐藏对话框
      d.setVisible(false);
    }
}

十四、文本对话框

/**
 * 文件对话框(FileDialogExample)是一种用于进行文件选择的组件，它是一个独立并且可以移动的窗口，允许用户对文件名进行浏览和选择。
 * 文件对话框可以分为两种类型，一种用于装入(load)或者说打开(open)文件，另一种用于保存文件。
 * 文件对话框FileDialog类是对话框Dialog的子类，它有三种构造方法：
 * (1)public FileDialog(Frame parent)构造一个不带标题、用于装入文件的文件对话框。
 * (2)public FileDialog(Frame parent,String title)构造一个不带标题、用于装入文件的文件对话框，其中String型参数title指定对话框的标题。
 * (3)public FileDialog(Frame parent,String title,int mode)构造一个不带标题的文件对话框，其中String型参数title指定对话框的标题，int型参数mode指定对话框的类型（它有两种可取值，分别为LOAD和SAVE。前者表示对话框用于装入文件，后者表示对话框用于保存文件）
 * @author ifwater
 *
 */

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

public class FileDialogExample
    implements ActionListener {
  Frame f;
  Button b;
  TextArea ta;
  FiledDialog fd;

  static public void main(String args[]){
    FileDialogExample = new FileDialogExample();
    fde.go();
  }

  public void go(){
    f = new Frame("FileDialog Example");
    b = new Button("Show FileDialog");
    b.addActionListener(this);
    f.add("South",b);

    ta = new TextArea();
    f.add("Center",ta);

    fd = new FileDialog(f,"FileDialog");
    f.setSize(350,150);
    f.setVisible(true);
  }

  public void actionPerformed(ActionEvent e){
    fd.setVisible(true);
    ta.setText("Directory: "+f.getDirectory());
    ta.append("\nFilename: "+fd.getFile());
  }
}

 

十五、菜单栏组件

    菜单按钮(MenuComponent)是一种特殊组建，只能被放在一种称为“菜单容器”的组件里。

（一）菜单栏
    菜单栏(MenuBar)是窗口中的主菜单，用来包容一组子菜单，它只有一个构造方法：
    MuneBar()
    菜单栏不支持事件监听程序，在菜单栏区域产生的所有事件都会被菜单栏自动处理。

（二）菜单
    菜单(Menu)中最基本的是下拉菜单。下拉菜单可以分为两种类型，一种是tear-off菜单，另一种是非tea-off菜单。二者的区别在于：当鼠标键被释放后，tear-off菜单的内容仍然显示在屏幕上。
    菜单有三种构造方式：
    (1)public Menu()构造一个不带标签的非tear-off菜单。
    (2)public Menu(String label)构造一个带指定标签的非tear-off标签，菜单的标签由String型参数指定。
    (3)public Menu(String label,boolean tearOff)构造一个带指定标签的菜单，菜单的标签由String型参数指定。boolean型参数指定菜单是否为tear-off型菜单。
    菜单可以被加入菜单栏或者另一个菜单中。通过MenuBar类中定义的setHelpMenu()方法可以指定某个菜单为帮助菜单。

（三）菜单项
    如果将整个菜单系统看作一棵树，那么菜单项(MenuItem)就是这棵树的叶子。菜单项通常被加入菜单中，它有三种构造方式：
    (1)public MenuItem()创造一个没有标签和快捷方式的菜单项
    (2)public MenuItem(String label)创建一个带标签但是没有快捷方式的菜单项
    (3)public MenuItem(String label,MenuShortcut s)创建一个带标签和快捷方式的菜单项
    当菜单中的菜单项被选中时，将会引发一个ActionEvent事件，因此通常需要为菜单项注册ActionListener以便对事件作出反应。

（四）带复选项的菜单项

/**
 *带复选框的菜单项(CeckboxMenuItem)是一种特殊的菜单项，在该菜单项的前面有一个复选框，可以对它进行选中或不选中操作。带复选框的菜单项有三种构造方法：
 * (1)public CheckboxMenuItem()构造一个没有标签，初态为未中的菜单项
 * (2)public CheckboxMenuItem(String label)构造一个有标签，初态未选中的菜单项
 * (3)public CheckboxMenuItem(String label,boolean state)构造一个有标签，初态由boolean型参数决定的菜单项
 * 当复选框的复选状态发生改变时，会引发ItemEvent事件，可以使用ItemListener中的itemStateChanged()对此事件进行响应。
 * 通常在建立菜单系统时，可以首先创建一个菜单栏并通过setMenuBar()方法将其放入某个框架，然后创建若干个菜单，通过add方法将他们加入到不同的菜单中。
 * @author ifwater
 */

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

public class MenuExample extends Frame
    implements ItemListener,ActionListener{
  TextField tf;

  //构造方法
  public MenuExample(){
    super("Menu Example");
    setSize(300,200);
  }

  public void init(){
    //建立菜单栏
    MenuBar mb = new MenuBar();
    setMenuBar(mb);

    //建立File菜单
    Menu m1 = new Menu("File");
    m1.add(new Menu("Open..."));
    MenuItem mil = new Menu("Save");
    mil.setEnabled(false);
    m1.add(mil);
    m1.add("Close");
    m1.addSeparator();
    m1.add("Exit");

    //注册监听程序
    m1.addActionListener(this);
    mb.add(m1);

    //建立Option菜单
    Menu m2 = new Menu("Option");
    m2.add("Front...");
  
    //建立子菜单
    Menu ms = new Menu("Coler...");
    ms.add("Foreground");
    ms.add("Background");
    ms.addActionListener(this);
    m2.add(ms);
  
    m2.addSeparator();
    CheckboxMenuItem cm = new CheckboxMenuItem("Always On Top");
    cm.addItemListener(this);
    m2.add(cm);
  
    m2.addActionListener(this);
    mb.add(m2);
  
    //建立Help菜单
    Menu h = new Menu("Help");
    h.add("about...");
  
    h.addActionListener(this);
    mb.setHelpMenu(h);
  
    tf = new TextField();
    add("South",tf);
  }
 
  public static void main(String args[]){
    MenuExample me = new MenuExample();
    me.init();
    me.setVisible(true);
  }
 
  //实现ItemListener接口中的方法
  public void itemStateChanged(ItemEvent e){
    tf.setText("ItemStateChanged");
  }
 
  //实现ActionListener接口中的方法
  public void actionPerformed(ActionEvent e){
    tf.setText(e.getActionCommand());
  
    if (e.getActionCommand()=="Exit"){
      System.exit(0);
    }
  }
}

（五）弹出式菜单

/**
 * 弹出式菜单(PopupMenu)是一种比较特殊的独立菜单，它需要通过add()方法加入某个组件，但是又不受布局管理器的控制。
 * 弹出式菜单有两种构造方法：
 * (1)public PopupMenu()构造一个没有名称的弹出式菜单
 * (2)public popupMenu(String label)构造一个有指定名称的弹出式菜单
 * 弹出式菜单需要依附在某个组件上，虽然也是通过add()方法实现的，但是却和普通的组建加入容器不太一样。因为弹出式菜单不受布局管理器的控制，并且在现实弹出式菜单时，必须调用show()方法：
 * public void show(Component origin,int x,int y)
 * 在这个方法中需要有一个组件作参数，该组件应该存在于弹出式菜单所依附的组件中，它的位置将作为显示弹出式菜单的参考原点。
 * 下面的程序是一个创建并显示弹出式菜单的例子
 */

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

public class PopupMenuExample
    implements ActionListener{
  Frame f;
  Button b;
  PopupMenu pm;

  public static void main(String args[]){
    PopupMenuExample pme = new PopupMenuExample();
    pme.init();
  }

  void init(){
    f = new Frame("PopupMenu Example");
    b = new Button("Press me");
    b.addActionListener(this);
    f.add(b,"Center");

    //创建弹出式菜单
    pm = new PopupMenu("Popup");
    //加入菜单项
    pm.add(new MenuItem("New"));
    pm.add(new MenuItem("Load"));
    pm.add(new MenuItem("Save"));
    pm.add(new MenuItem("Save as..."));
    f.add(pm);
    f.setSize(200,200);
    f.setVisible(true);
  }
 
  //实现ActionListener接口
  public void actionPerformed(ActionEvent e){
    //以按钮b的位置为参考原点，在(10,10)显示弹出式菜单
    pm.show(10,10);
  }
}

 

十六、控制组件外观

/**
 * （一）颜色
 * 可以使用下面的两个方法设置组件的前景色和背景色：
 * (1)public void setForeground(Color c)设置前景颜色
 * (2)public void setBackground(Color c)设置背景颜色
 * 在这两种方法中，都需要java.awt.Color类的一个实例作为参数，既可以使用Color类中预定义的颜色常量，也可以自己创建新的颜色。
 * （二）字体
 * 可以使用setFont(Font f)方法对组件中文本的字体进行设定，这俄国方法需要java.awt.Font类的一个实例作参数。在Java中并没有预定义的字体常量，因此需要通过给定字体名称、风格和大小自己创建Font对象。例如：
 * Font f = new Font("TimesRoman",Font.PLAIN,14);
 * Font构造方法的第一个参数是字体名称，第二个参数是字体的风格，第三个参数是字体的大小，其中有效的字体名称包括：
 * Dialog
 * Helvetica
 * TimeRoman
 * Courier
 * SansSerif
 * Serif
 * Monospaced
 * DialogInput
 * ZapfDingbats
 * 字体风格可以是以下几种常量之一：
 * Font.BOLD
 * Font.ITALIC
 * Font.PLAIN
 * Font.BOLD+Font.ITLAIC
 */

import java.awt.*;

public class SetFontExample{
  public static void main(String args[]){
    Frame f = new Frame("Set Font Example");
    f.setLayout(new FlowLayout());
  
    Font f1,f2,f3,f4;
  
    f1 = new Font("Dialog",Font.PLAIN,20);
    f2 = new Font("Helvetica",Font.PLAIN,20);
    f3 = new Font("TimesRoman",Font.PLAIN,20);
    f4 = new Font("Courier",Font.PLAIN,20);
  
    TextField tf1,tf2,tf3,tf4;
  
    tf1 = new TextField(10);
    tf1.setFont(f1);
    tf1.setText("Hello");
    tf1.add(tf1);

    tf2 = new TextField(10);
    tf2.setFont(f2);
    tf2.setText("Hello");
    tf2.add(tf2);

    tf3 = new TextField(10);
    tf3.setFont(f3);
    tf3.setText("Hello");
    tf3.add(tf3);

    tf4 = new TextField(10);
    tf4.setFont(f4);
    tf4.setText("Hello");
    tf4.add(tf4);
  
    f.setSize(300,150);
    f.setVisible(true);
  }
}

 

十七、打印
    打印的方式与屏幕显示的方式类似：在打印之前，首先要获取java.awt.Graphics类的一个特殊对象。可以使用Graphics类中的任意绘图方法进行打印，或者，可以让组件将其自身绘制到Graphics对象中。