java GUI 2

图像显示

使用Graphics.drawImage(Image img,int x,int y,ImageObserver observer)方法在组件上显示图像，方法的第一个参数为要显示的图像，第二、三个参数为图像在组件上显示时，在图像上所取的左上角的坐标，第四个参数为图像监视器。由于该方法是异步的，就有可能使得要显示的图像还未完全加载到内存时，方法就返回了，这就需要有实现了ImageObserver接口的类，来监视图像的加载进度。Component类均实现了这个接口，所以要显示图像的那个组件对象，就可以作为图像监视器。

使用Component.getToolkit.getImage(String path)语句获取Image对象。

编程举例：在窗口上显示图像文件中的图像，并解决由于drawImage内部实现机制所造成的图像不能显示问题，和实现图像的永久化显示。

import java.awt.*;

import java.awt.event.*;

public class DrawImage extends Frame{

       Image img=getToolkit().getImage("yang.jpg");

    public DrawImage()

    {

           addWindowListener(new WindowAdapter(){

               public void windowClosing(WindowEvent e)

               {

                      dispose();

                   System.exit(0);

               }

        });

    }

    public void paint(Graphics g)

    {

           g.drawImage(img,5,5,this);

           //在paint方法中无需while循环来不断加载图像

    }

    public static void main(String[] args) {

           DrawImage drawFrame=new DrawImage();

         drawFrame.setSize(450,550);

           drawFrame.setTitle("图像显示");

           drawFrame.setVisible(true);

           /*Graphics g=drawFrame.getGraphics();

           //getGraphics()应在组件显示后调用，否则会返回null

           while(!g.drawImage(img,5,5,drawFrame));

           //若图像加载完毕drawImage方法返回true,因此会不断加载图像。*/

   }

}

 

双缓冲技术：

用Component.createImage方法创建内存Image对象，在该Image对象上进行绘制的结果就成了一幅图像。在Image对象上执行与组件表面同样的绘制，Image对象中的图像是组件表面内容的复制，当组件重画时，只需将内存中的Image对象在组件上显示出就可以了。

 

编程举例：使用双缓冲技术重绘组件表面的所有图形。

 

import java.awt.*;

import java.awt.event.*;

import java.util.*;

public class DrawLine1 extends Frame{

    int X,Y;

    int endX,endY;

    Image img=null;

    Graphics gc=null;

     public DrawLine1()

       {

              setTitle("Hello");

           setSize(400,400);

           setVisible(true);//当组件第一次显示时，系统也会调用paint方法。

              Dimension d=getSize();

              img=this.createImage(d.width,d.height);

              gc=img.getGraphics();

        //该方法应在组件显示后调用，否则会返回null

              addMouseListener(new MouseAdapter(){

                     public void mousePressed(MouseEvent e)

                     {

                            X=e.getX();Y=e.getY();

                     }

                     public void mouseReleased(MouseEvent e)

                     {

                            endX=e.getX();endY=e.getY();

                            Graphics g=getGraphics();

                            g.drawString("始："+X+","+Y,X,Y);

                            g.drawString("终："+endX+","+endY,endX,endY);

                            g.drawLine(X,Y,e.getX(),e.getY());

                            gc.drawString("始："+X+","+Y,X,Y);

                            gc.drawString("终："+endX+","+endY,endX,endY);

                            gc.drawLine(X,Y,e.getX(),e.getY());

                     }

              });

              addWindowListener(new WindowAdapter(){

               public void windowClosing(WindowEvent e)

               {

                      dispose();

                   System.exit(0);

               }

        });

       }

    public void paint(Graphics g)

    {

           if(img!=null)

                  g.drawImage(img,0,0,this);

 

    }

    public static void main(String[] args) {

           DrawLine1 drawFrame=new DrawLine1();

 

    }

}

 

Canvas

Canvas是具有最基本和最简单的GUI功能的组件，代表屏幕上的一块空白的区域，程序能够在这个部件表面绘图，也能够捕获用户的操作，产生相应的事件。当我们要设计自定义的具有GUI功能的组件类时，可以采用继承Canvas的方法，这时的子类便具有了组件的基本特征，我们只需设计它的外观和功能就可以了。

编程举例：设计一个自定义的计时器组件，当鼠标在计时器组件上按下时，计时器开始计时，并显示计时时间，当鼠标释放时，计时器停止计时。

import java.awt.*;

import java.awt.event.*;

public class TestStopWatch extends Frame{

 

    public TestStopWatch()//主界面

    {

           this.setTitle("计时器");

           this.setSize(400,400);

           this.setVisible(true);

           this.add(new StopWatch());

        addWindowListener(new WindowAdapter(){

               public void windowClosing(WindowEvent e)

               {

                      dispose();

                   System.exit(0);

               }

        });

    }

    public static void main(String[] args) {

        TestStopWatch mainFrame=new TestStopWatch();

    }

}

 

import java.awt.Canvas;

import java.text.*;

import java.util.*;

import java.awt.*;

import java.awt.event.*;

public class StopWatch extends Canvas implements Runnable{

       long startTime=0;

       long endTime=0;

    boolean start=false;

       public StopWatch()

       {

              this.enableEvents(AWTEvent.MOUSE_EVENT_MASK);

       }

       protected void processMouseEvent(MouseEvent e)

       {

              if(e.getID()==MouseEvent.MOUSE_PRESSED)

              {

                     startTime=endTime=System.currentTimeMillis();

                     repaint();

                     start=true;

                     new Thread(this).start();

              }

              else if(e.getID()==MouseEvent.MOUSE_RELEASED)

              {

                     endTime=System.currentTimeMillis();

                     repaint();

                     start=false;

              }

       }

       public void paint(Graphics g)

       {

              Date elapsedTime=null;

              SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");

              try

              {

                     elapsedTime=sdf.parse("00:00:00");

              }

              catch(Exception e)

              {

                     e.printStackTrace();

              }

              elapsedTime.setTime(elapsedTime.getTime()+endTime-startTime);

              String strTime=sdf.format(elapsedTime);

              g.fill3DRect(0,0,80,30,true);

              g.setColor(Color.WHITE);

              g.drawString(strTime,10,20);

       }

       public void run()

       {

              while(start)

              {

                     try

                     {

                            Thread.sleep(400);

                     }

                     catch(Exception e)

                     {

                            e.printStackTrace();

                     }

                     endTime=System.currentTimeMillis();

                     repaint();

              }

       }

}

 

菜单

java中于菜单相关的类主要有：MenuBar（菜单条）、Menu（菜单）、MenuItem(菜单项)。MenuBar可以通过add方法加入Menu，Menu也可以通过add方法加入相应的MenuItem，在菜单中可以嵌套菜单。我们不用对单击Menu的事件进行处理，它默认显示相应的菜单项。但是要对单击菜单项的事件进行处理。

在菜单中加入分隔符：addSeparator();

创建带复选标记的菜单项：

CheckboxMenuBarItem file=new CheckboxMenuItem(“Quit”,true);

对于能发出ActionEvent的组件都可以调用setActionCommand方法，与相应的组件关联一个字符串，用于指示组件的动作所要执行的命令，因此可以用ActionEvent的对象调用getActionCommand方法返回刚才以setActionCommand方法为事件源的组件的命令字符串。

 

Container

Container类是所有容器的类的父类，调用其add方法，可以将组件添加到容器中。Container也是Component的子类，因此也可以作为组件添加到其他容器中。

Container类主要包括Window与Panel两个子类：

我们很少直接使用Window类，而是使用它的子类。容器在显示出来以后，就不能再向其中加入组件了，否则组件无法正常显示。

 

Dialog与FileDialog类

Dialog（对话框）不能独立存在，必须有一个上级窗口，该窗口就是这个对话框的拥有者。对话框分两种形式：模态对话框和非模态对话框。模态对话框显示的时候，用户不能够操作同一个程序中的其他窗口，只有关闭模态对话框才能进行其他的操作。而非模态对话框显示的时候，用户能够操作同一个程序中的其他窗口。

Dialog类的两个常用构造方法：

public Dialog(Frame owner,String title);//默认的是非模态对话框

public Dialog(Frame owner,String title,boolean modal);第三个参数表示对话框的模式true表示对话框为模态的。

 

编程举例：主框架窗口通过两个按钮分别打开一个模态对话框和一个非模态对话框，并与这两个对话框进行数据交换。

import java.awt.*;

import java.awt.event.*;

public class TestDialog extends Frame {

//主界面

    private TextField text=new TextField(10);

    //text对象需要数据交换，定义成成员变量

    public TestDialog()

    {

           Button b1=new Button("打开模态对话框");

           Button b2=new Button("打开非模态对话框");

           this.add(text,"North");

           this.add(b1,"Center"); this.add(b2,"East");

           b1.addActionListener(new ActionListener()

           {

                  public void actionPerformed(ActionEvent e)

                  {

                         MyDialog dlog=new MyDialog(TestDialog.this,"model dialog",true);

                         //注意第一个参数的表示方法，代表外部类

                         dlog.setInfo(text.getText());

                         dlog.setVisible(true);

                  /*由于dlog是模态的，因此在这个对话框显示后，程序无法进行其他的

                  *操作,对话框关闭之前，以下的代码无法执行*/

                          text.setText(dlog.getInfo());

                  }

           });

           b2.addActionListener(new ActionListener()

           {

                  public void actionPerformed(ActionEvent e)

                  {

                  MyDialogd log=new MyDialog(TestDialog.this,"modalless dialog",false);

                       dlog.setInfo(text.getText());

                         dlog.setVisible(true);

                        //tf.setText(dlg.getInfo());

                        /*由于是非模态的，因此在这个对话框显示后，不能立即执行语句:

                         *tf.setText(dlg.getInfo());*否则用户来不及输入信息*/

                    }

           });

           addWindowListener(new WindowAdapter(){

               public void windowClosing(WindowEvent e)

               {

                      dispose();

                   System.exit(0);

               }

        });

    }

    public void setInfo(String str)

    {

           text.setText(str);

    }

       public static void main(String[] args) {

          TestDialog mainFrame=new TestDialog();

          mainFrame.setSize(400,400);

          mainFrame.setVisible(true);

       }

}

 

import java.awt.*;

import java.awt.event.*;

public class MyDialog extends Dialog {//对话框

       private TextField tf=new TextField(10);

       private String stringInfo="";

       public MyDialog(Frame owner,String title,boolean modal)

       {

              super(owner,title,modal);

              setBounds(0,0,200,150);

 

              Button b1=new Button("应用");

              Button b2=new Button("确定");

              add(tf,"North"); add(b1,"Center");

              add(b2,"East");

 

              if(isModal())

              {

                     b1.setEnabled(false);

              }

              b1.addActionListener(new ActionListener()

              {

                     public void actionPerformed(ActionEvent e)

                     {

                            ((TestDialog)MyDialog.this.getOwner()).setInfo(tf.getText());

                     }

              });

              b2.addActionListener(new ActionListener()

              {

                     public void actionPerformed(ActionEvent e)

                     {

                            if(isModal())

                            {

                                   stringInfo=new String(tf.getText());

                            }

                            else

                            {

                                   ((TestDialog)MyDialog.this.getOwner()).setInfo(tf.getText());

                            }

                            dispose();

                     }

              });

       }

       public String getInfo()

       {

              return stringInfo;

       }

       public void setInfo(String stringInfo)

       {

              tf.setText(stringInfo);

       }

}

FileDialog类是Dialog类的一个子类，能够产生标准的文件存取对话框。即能产生文件打开、文件另存为这样的对话框，它已经有显示外观，构造函数中有一个modal参数决定是打开文件，还是另存储文件，并且由于安全性问题该对话框不能用在applet中。

 

Checkbox类

Checkbox类用来建立单选按钮和多选按钮。

创建多选按钮，只需要使用构造函数：Checkbox(String label,boolean state)，后一个参数表示默认的选中状态。

创建单选按钮，需要使用构造函数：

Checkbox(String label,boolean state,CheckboxGroup group),只要最后一个参数对象相同，就在同一组内。

单选按钮和多选按钮的语义事件为ItemEvent，对应的监听器接口为ItemListener，该接口只有一个itemStateChanged（ItemEvent e）方法。ItemEvent中的主要方法：

getItemSelectable(),返回产生事件的组件；getStateChange()，返回组件状态更改后的类型，返回值为ItemEvent类中的静态常量：SELECTED、DESELECTED

确定一组多选按钮中，被选中的选项，除了用ItemEvent类中的方法外，也可用CheckboxGroup类中的getSelectedCheckbox()方法返回被选中的选项，若没有则返回null。

 

Choice类（下拉菜单）

Choice类，使用add方法加入条目，语义事件为ItemEvent，对应的监听器接口为ItemListener，该接口只有一个itemStateChanged（ItemEvent e）方法。调用ItemEvent类中的getItem方法返回被选择的条目。

 

Panel与ScrollPane类

Panel类是一个容器类，用于产生一种特殊的空白面板，可以容纳其他的组件，但不能独立存在，Panel类常用于将几个组件集中放在窗口上。

ScrollPane类是一种容器类，用于产生滚动窗口，通过滚动条在一个较小的容器中显示较大的子部件。ScrollPane不能独立存在，必须添加到其他的容器中。ScrollPane类没有布局管理器，只能存放一个组件，若要将几个组件放在ScrollPane中，可将它们先放在Panel中，然后再存放在ScrollPane上。