GUI学习记录1

1. Awt小程序 ：

import java.awt.*;
public class testFrame {
    public static void main(String[] args) {
        Frame f = new Frame();
        f.setName("frame");
        f.setSize(500, 600);
        f.add(new Button("hello"));
        f.setVisible(true);
        try{
            Thread.sleep(5000);
        }catch(Exception e){
            e.printStackTrace();
        }
        f.dispose();
    }
}

2 java的事件处理机制

三个重要概念：

事件：用户对组件的一个操作

事件源：发生事件的组件

事件处理器：某个java类中负责处理事件的成员方法

事件分类：

按事件的物理操作和GUI组件的表现效果进行分类：

MouseEvent,WindowEvent,ActionEvent

一个事件监听器对象负责处理一类事件

一类事件的每一种方法发生情况，分别由事件监听器对象中的一个方法具体实现

在事件源和事件监听器对象中进行约定的接口类（事件监听接口）

事件监听器接口类名称与事件类的名称是相对应的

如果要处理发生在GUI组件上的XXXEvent时间的处理通用流程：

1.编写一个实现了XXXListener接口的事件监听器类；

2.xxxListener类中的用于处理事件情况的方法中，编写处理代码

3.调用组件的addxxxListener方法，将类xxxListener创建的实例对象注册到GUI组件上

import java.awt.*;
public class testFrame {
    public static void main(String[] args) {
        Frame f = new Frame();
        f.setName("frame");
        f.setSize(500, 600);
        f.add(new Button("hello"));
        f.setVisible(true);
        f.addWindowListener(new MyListener());
        //注册窗口监听对象
    }
}
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.Window;
 
public class MyListener implements WindowListener {
    @Override
    public void windowActivated(WindowEvent e) {
    }
    @Override
    public void windowClosed(WindowEvent e) {
    }
    @Override
    public void windowClosing(WindowEvent e) {
        e.getWindow().setVisible(false);
        ((Window)e.getComponent()).dispose();
        //dispose方法在java.awt.Window包中
        //需要把getComponet转换为window类型才能调用dispose方法
    }
    @Override
    public void windowDeactivated(WindowEvent e) {
    }
    @Override
    public void windowDeiconified(WindowEvent e) {
    }
    @Override
    public void windowIconified(WindowEvent e) {
    }
    @Override
    public void windowOpened(WindowEvent e) {
    }
}
//以上各方法都需要写出来，都必须对接口方法进行实现

3.方法适配器

JDK中提供了大多数事件监听接口最简单的实现类

用事件适配器来处理事件，可以简化事件监听器来编写

监视器，适配器类在awt.event包中

只要继承了WindowAdapter，就不需要全部写出上面程序中七个方法，只需要写出覆 盖的方法

解决适配器思路：

-方法没有被调用？还是方法中的程序代码的执行问题？

-方法名写错了？还是没有注册事件监听器

事件适配器的不足之处：

Java不允许一个类继承两个类，如果一个类已经继承了一个类，就不能再继承适配器类了

import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class AdaperListener extends WindowAdapter {
    //注意这个方法的大小写！否则不会被调用
    public void windowClosing(WindowEvent e){
        System.out.println("aba");
        e.getWindow().dispose();
        //释放屏幕资源
        System.exit(0);
    }
}
f.addWindowListener(new AdaperListener());

4. Button监听

import java.awt.Button;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class ButtonAdapter implements ActionListener {
    Frame f = new Frame("Hello!");
    //static ButtonAdapter ba = new ButtonAdapter();
    public void init(){
        Button btn = new Button("hello");
        f.add(btn);
        btn.addActionListener(this);
        //监听当前对象
    }
    public void set(){
        f.setSize(500,400);
        f.setVisible(true);
    }
    public static void main(String args[]){
        ButtonAdapter ba = new ButtonAdapter();
        ba.init();
        ba.set();
    }
   
    public void actionPerformed(ActionEvent e) {
        f.dispose();
    }
}
把上述程序改写成为类中类程序：
import java.awt.Button;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ButtonAdapter {//implements ActionListener {
    Frame f = new Frame("Hello!");
    //static ButtonAdapter ba = new ButtonAdapter();
    public void init(){
        Button btn = new Button("hello");
        f.add(btn);
        btn.addActionListener(new actionAdapter());
        //监听当前对象
    }
    public void set(){
        f.setSize(500,400);
        f.setVisible(true);
    }
    public static void main(String args[]){
        ButtonAdapter ba = new ButtonAdapter();
        ba.init();
        ba.set();
    }
    class actionAdapter implements ActionListener{
        public void actionPerformed(ActionEvent e) {
        f.dispose();
        }
    }
}
把上述程序继续改写成为匿名类：
btn.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                f.dispose();
            }
        });
建议：在编程的时候，不要盯着静态的代码，而是联想着对象的变化
5. 修改组件的默认事件处理方式
protected final void enableEvent(long eventsToEnable)方法，启用由传递给次组件的指定事件掩码参数所定义的事件，当将某个事件类型的事件添加到这个组件时候，自动启用该事件类型，只能由Component的子类调用，该子类需要将指定的事件类型传递给processEvent，而不管是否已注册了侦听器
import java.awt.AWTEvent;
import java.awt.Button;
import java.awt.Frame;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
class MyButton extends Button{
    private MyButton friend = null;
    public MyButton(String title){
        super(title);
        this.enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);
    }
    protected void processMouseMotionEvent(MouseEvent e){
        this.setVisible(false);
        friend.setVisible(true);
    }
    public void setFriend(MyButton friend){
        this.friend = friend;
    }
}
public class TestMybutton extends Frame{
    public TestMybutton(){
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                dispose();
                //dispose调用位置在new WindowAdapter()中，这个时候this是               指WindowAdapter的对象，所以要用this的时候，应该这样写：                 TestMybutton.this.dispose();
                }
        });
    }
    public static void main(String[] args) {
        System.out.println("Starting TestMybutton!");
        TestMybutton mainFrame = new TestMybutton();
        mainFrame.setSize(400,400);
        mainFrame.setTitle("hello");
        MyButton btn1 = new MyButton("快来抓我啊！");
        MyButton btn2 = new MyButton("快来抓我啊！");
        btn1.setFriend(btn2);
        btn2.setFriend(btn1);
        mainFrame.add(btn1,"North");
        mainFrame.add(btn2,"South");
        mainFrame.setVisible(true);
        btn1.setVisible(false);
        //这里要注意mainFrame的setVisable方法的调用时间 
    }
}

6. GUI组件上的图形操作

(1).Graphics类与图形绘制

drawLine,drawString(x,y坐标是相对应左下角)

(2).组件重绘处理

移动窗口原来绘制的图形就没有，这叫做窗口重绘

使用pait(Graphics g)来重绘

调用pait方法时候，是repaint方法调用update方法，update方法再 调用pait方法的过程

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Enumeration;
import java.util.Vector;
 
class MyLine{
    private int orgX;
    private int orgY;
    private int endX;
    private int endY;
    public MyLine(int orgX,int orgY,int endX,int endY){
        this.orgX = orgX;
        this.orgY = orgY;
        this.endX = endX;
        this.endY = endY;
    }
    public void drawMe(Graphics g){
        g.drawLine(orgX, orgY, endX, endY);
    }
    //定义一个集合类
   
   
}
public class DrawLine extends Frame{
    int orgX,orgY;
    int endX,endY;
    MyLine line;
    Vector vLines = new Vector();
    public void paint(Graphics g){
        Enumeration e = vLines.elements();
        while(e.hasMoreElements()){
            line = (MyLine) e.nextElement();
            line.drawMe(g);
        }
    }
    public DrawLine(){
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                dispose();
            }
        }
        );
        this.addMouseListener(new MouseAdapter(){
            public void mousePressed(MouseEvent e){
                orgX = e.getX();
                orgY = e.getY();
            }
            public void mouseReleased(MouseEvent e){
                endX = e.getX();
                endY = e.getY();
                Graphics g = getGraphics();
                /*g.setColor(Color.RED);
                g.drawString(orgX+","+orgY, orgX, orgY);
                g.drawString(e.getX()+","+e.getY(), e.getX(), e.getY());
                g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
                //字体名称，字体样式，字体磅值
                g.drawLine(orgX,orgY,e.getX(),e.getY());
                */
        VLines.add(new MyLine(orgX,orgY,endX,endY));
                repaint();
            }
        }
        );
    }
    public static void main(String args[]){
        DrawLine mainFrame = new DrawLine();
        mainFrame.setTitle("hello!");
        mainFrame.setSize(400,400);
        mainFrame.setVisible(true);
    }
}

(3).图形处理

可以通过Graphics.drawImage

(Image img,int x,int y,ImageObserver observer)来显示图像

使用Component.getTollkit.getImage(String path)获得Image 实例对象

import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
public class DrawImage extends Frame{
    Image img = getToolkit().getImage("C://Users//姜康//Desktop//网页练习//a.jpg");
    public void paint(Graphics g){
        g.drawImage(img, 200, 200, this);
    }
    public DrawImage(){
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                DrawImage.this.dispose();
            }
        }
        );
    }
    public static void main(String args[]){
        DrawImage mainFrame = new DrawImage();
       
       
        mainFrame.setVisible(true);
        Graphics g = mainFrame.getGraphics();
    //  while(!g.drawImage(img, 0, 0, mainFrame)){
           
        //}
        //mainFrame.getGraphics().drawImage(img, 0, 0, mainFrame);
        mainFrame.setTitle("hello!");
        mainFrame.setSize(400,400);
       
    }
}

7. 双缓冲技术

Component.CreatImage方法创建内存Image对象

在Image对象上进行绘制的结果就成了一幅图像

在Image对象上执行与组件表面同样的绘制，Image对象中的图像时组件表面内容的 复制，当组件重画时候，只需要将内存中的Image对象在组件上画出

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
@SuppressWarnings("serial")
public class DrawLines extends Frame{
    private int orgX;
    private int orgY;
    private int endX;
    private int endY;
    Image oimg = null;
    Graphics og = null;
    public void paint(Graphics og){
        if(oimg != null){
            og.drawImage(oimg, 0, 0, this);
        }
    }
    public DrawLines(){
        setTitle("hello");
        setSize(1000,1000);
        setVisible(true);
        //Dimension代表窗口的大小
        Dimension d = this.getSize();
        oimg = this.createImage(d.width, d.height);
        og = oimg.getGraphics();
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                dispose();
            }
        });
        this.addMouseListener(new MouseAdapter(){
            public void mousePressed(MouseEvent e){
                orgX = e.getX();
                orgY = e.getY();
            }
        });
        this.addMouseListener(new MouseAdapter(){
            public void mouseReleased(MouseEvent e){
                endX = e.getX();
                endY = e.getY();
                og.setColor(Color.RED);
                og.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
                og.drawString(orgX+","+orgY, orgX, orgY);
                og.drawString(endX+","+endY, endX, endY);
                og.drawLine(orgX,orgY,endX,endY);
                repaint();//一定要加上repaint方法！
            }
        });
    }
    public static void main(String args[]){
        @SuppressWarnings("unused")
        DrawLines mainframe = new DrawLines();
    }
}

8. AWT组件

(1). Component类

Java图形用户界面最基本的组成部分是组件，组件式一个可以以图形化的方式显示在屏幕上，并能与用户进行交互的对象（按钮，标签）。

它是所有GUI组件的父类，

(2).Cannas类

代表屏幕上的一块空白矩形区域，程序能够在这个部件表面绘图，也能够捕获操作，产生相应的事件，如果自定义GUI功能的组件时，可以继承Canvas，将简化编程

import java.awt.AWTEvent;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class SetTimer extends Canvas implements Runnable{
    long startTime = 0;
    long endTime = 0;
    boolean bStart = true;
    public SetTimer(){
        enableEvents(AWTEvent.MOUSE_EVENT_MASK);
    }
    protected void processMouseEvent(MouseEvent e){
        System.out.println("dsfa");
        if(e.getID() == MouseEvent.MOUSE_PRESSED){
            bStart = true;
            startTime = endTime = System.currentTimeMillis();
            repaint();
            new Thread(this).start();
        }
        else if(e.getID() == MouseEvent.MOUSE_RELEASED){
            endTime = System.currentTimeMillis();
            repaint();
            bStart = false;
        }
        super.processMouseEvent(e);
    }
    public void paint(Graphics g){
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        Date dt = null;
        try {
            dt = sdf.parse("00:00:00");
        } catch (ParseException e1) {
            e1.printStackTrace();
        }
        dt.setTime(dt.getTime()+endTime-startTime);
        String strTime = sdf.format(dt);
        g.fill3DRect(0, 0, 78, 28, true);
        //默认填充色为黑色，必须在setColor前填充，否则看不出来
        g.setColor(Color.WHITE);
        g.drawString(strTime, 10, 20);
    }
    public void run(){
        while(bStart){
            try{
                Thread.sleep(500);
            }catch(Exception e){
                e.printStackTrace();
            }
            endTime = System.currentTimeMillis();
            repaint();
        }      
    }
}

(3). 菜单类

菜单由菜单条，菜单，菜单项组成

MenuBar(菜单条)、Menu(菜单)、MenuItem(菜单项)

import java.awt.event.*; 
public class MenuListner implements ActionListener{
    public void actionPerformed(ActionEvent e){
        if(e.getActionCommand().equals("printview")){
            System.out.println("doing printview");
        }
        else if(e.getActionCommand().equals("setting")){
            System.out.println("doing setting");
        }
    }
}
 
import java.awt.*;
import java.awt.event.*;
 
public class TestMenuBar extends Frame{
    MenuBar menubar = new MenuBar();
    Menu fileM = new Menu("File");
    Menu editM = new Menu("Edit");
    Menu toolsM = new Menu("Tools");
    Menu helpM = new Menu("Help");
    MenuItem fileMI1 = new MenuItem("New");
    MenuItem fileMI2 = new MenuItem("Open");
    MenuItem fileMI3 = new MenuItem("Save");
    Menu fileM4 = new Menu("print");
    MenuItem printMI1 = new MenuItem("printview");
    MenuItem printMI2 = new MenuItem("setting");
    CheckboxMenuItem fileMI5 =
new CheckboxMenuItem("Quit",true);
    public TestMenuBar(){
        menubar.add(fileM);
        menubar.add(editM);
        menubar.add(toolsM);
        menubar.add(helpM); 
        fileM.add(fileMI1);
        fileM.add(fileMI2);
        fileM.add(fileMI3);
        fileM.add(fileM4);
        fileM4.add(printMI1);
        fileM4.add(printMI2);
        fileM.addSeparator();
        fileM.add(fileMI5);
        this.setMenuBar(menubar);
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                dispose();
            }
        });
        MenuListner m1 = new MenuListner();
        printMI1.addActionListener(m1);
        printMI2.addActionListener(m1);
    }
    public static void main(String args[]){
        TestMenuBar mainFrame = new TestMenuBar();
        mainFrame.setSize(400,400);
        mainFrame.setTitle("menu");
        mainFrame.setVisible(true);
    }
}

(4).Container类是所有容器类的父类,Container.add方法用于将组件添加到容 器中

Container也是Component的子类,因此可以作为组件增加到其他容器上

Dialog与FileDialog类是Container类的子类

模态对话框与非模态对话框

Dialog类的两个构造方法

public Dialog(Frame owner,String title)非模态

public Dialog(Frame owner,String tile,boolean modal)可指定

package testmenubar;
 
import java.awt.*;
import java.awt.event.*;
 
public class MyDialog extends Dialog {
    protected static final String TestDialog = null;
    private TextField tf = new TextField(10);
    private String strInfo = null;
    public MyDialog(Frame owner,String title,boolean model){
        super(owner,title,model);
        setBounds(0,0,200,150);
       
        Button b1 = new Button("应用");
        Button b2 = new Button("确定");
        this.add(tf,"North");
        this.add(b1,"Center");
        this.add(b2,"East");
       
        if(this.isModal() == true){
            b1.setEnabled(false);
        }
        b1.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                ((TestDialog)getOwner()).tf.getText();
            }
        });
        b2.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                if(isModal() == true){
                    strInfo = new String(tf.getText());
                }
                else{
                    ((TestDialog)getOwner()).setInfo(tf.getText());
                }
                dispose();
            }
        });
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
               
                dispose();
            }
        });
    }
    public String getInfo(){
        return strInfo;
    }
    public void setInfo(String strInfo){
        tf.setText(strInfo);
    }
}package testmenubar;
 
import java.awt.*;
import java.awt.event.*;
 
public class TestDialog extends Frame{
    TextField tf = new TextField(10);
    public TestDialog() {
        Button b1 = new Button("打开模态对话框");
        Button b2 = new Button("打开非模态对话框");
   
        add(tf, "North");
        add(b1, "Center");
        add(b2, "East");
       
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                dispose();
            }
        });
        b1.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                MyDialog dlg = new MyDialog(TestDialog.this,"modal dialog",true);
                dlg.setInfo(tf.getText());
                dlg.setVisible(true);
                tf.setText(dlg.getInfo());
            }
        });
        b2.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                MyDialog dlg = new MyDialog(TestDialog.this,"modaless dialog",false);
                dlg.setInfo(tf.getText());
                dlg.setVisible(true);
                tf.setText(dlg.getInfo());
            }
        });
        Button b3 = new Button("确定");
    }
    public static void main(String[] args) {
        TestDialog mainFrame = new TestDialog();
        mainFrame.setSize(400, 400);
        mainFrame.setVisible(true);
    }
    public void setInfo(String text) {
        return;
       
    }
}