JAVAawt

三个概念：组件（component） 容器（Container） 布局管理器（LayoutManager）

关系: 容器中放置组件，组件的排列方式可以通过布局管理器设置。

用户设置布局管理器后，setLocation()等方法会被布局管理器覆盖；用户想亲自设置组件大小和位置，应取消容器的布局管理器

setLayout(null);

有三种类型的容器：Window,Panel,ScrollPane

常用的有Frame,Panel,Applet

1. Frame

　　生成一个窗口，一般不用Window, 而是用其子类Frame。

　　实例化后，Frame是不可见且无大小。故需调用setSize() setVisible(true)

import java.awt.*;

public class MyFrame extends Frame {
    public static void main(String args[]) {
        MyFrame fr = new MyFrame("Hello Out There!");

        fr.setSize(200, 200); // 设置Frame的大小, 缺省为(0 ,0)
        fr.setBackground(Color.red); // 设置Frame的背景，缺省为红色
        fr.setVisible(true); // 设置Frame为可见，缺省为不可见
    }

    public MyFrame(String str) {
        super(str); // 调用父类的构造方法
    }
}

2. Panel

　　eg: 带有Panel的Frame

　　

import java.awt.*;

public class FrameWithPanel extends Frame {
    public FrameWithPanel(String str) {
        super(str);
    }

    public static void main(String args[]) {
        FrameWithPanel fr = new FrameWithPanel("Frame with pannel");
        Panel pan = new Panel();
        fr.setSize(200, 200);
        fr.setBackground(Color.red);

        fr.setLayout(null); // 取消布局管理器

        pan.setSize(100, 100); 
        pan.setBackground(Color.yellow); // 设置面板pan的背景颜色为黄色

        fr.add(pan); // 用add方法把pan面板添加到框架fr中

        fr.setVisible(true);
    }
}

3. LayoutManger布局管理器

　　组件的排列顺序、组件的大小、位置、当窗口移动或调整大小后组件如何变化可授权给布局管理器来管理。

　　不同的布局管理器其算法和策略不同。

　　FlowLayout

　　　　Panel和Applet的缺省布局管理器。

　　　　其规律为从上到下，从左到右放置。

　　　　容器发生变化时，组件大小不变，相对位置改变。

　　　　构造方法：

　　　　　　FlowLayout(FlowLayout.RIGHT, 20, 40); // 右对齐，横向间隔20，纵向间隔40

　　　　　　FlowLayout(FlowLayout.LEFT); // 左对齐，横向间隔、纵向间隔缺省：5

　　　　　　FlowLayout(); // 居中对齐，横向间隔、纵向间隔缺省：5

eg. Frame采用FlowLayout()

import java.awt.*;

public class myButtons {
    public static void main(String args[]) {
        Frame f = new Frame();
        f.setLayout(new FlowLayout());
        Button button1 = new Button("OK");
        Button button2 = new Button("Open");
        Button button3 = new Button("Close");
        f.add(button1);
        f.add(button2);
        f.add(button3);

        f.setSize(300, 100);
        f.setVisible(true);
    } 

　　BorderLayout

　　　　Window, Frame和Dialog的缺省布局管理器

　　　　有5个区域：North South East West Center

　　　　容器发生变化时，组件相对位置不变，组件大小改变

eg. Frame采用BorderLayout

import java.awt.*;

public class buttonDir {
    public static void main(String args[]) {
        Frame f = new Frame("BorderLayout");
        f.setLayout(new BorderLayout());
        f.add("North", new Button("North"));
        f.add("South", new Button("South"));
        f.add("East", new Button("East"));
        f.add("West", new Button("West"));
        f.add("Center", new Button("Center"));

        f.setSize(200, 200);
        f.setVisible(true);
    }
}

　　GridLayout

　　　　容器中各个组件呈网格状布局，平均占据容器的空间

eg. GridLayout生成3行2列的布局。

import java.awt.*;

public class ButtonGrid {
    public static void main(String args[]) {
        Frame f = new Frame("GridLayout");
        f.setLayout(new GridLayout(3, 2)); // 容器平均分成3行2列
        f.add(new Button("1")); // 第一行第一格
        f.add(new Button("2")); // 第一行下一格
        f.add(new Button("3")); // 第二行第一格
        f.add(new Button("4")); // 第二行下一格
        f.add(new Button("5")); // 第三行第一格
        f.add(new Button("6")); // 第三行下一格
        f.setSize(200, 200);
        f.setVisible(true);
    }
}

　　CardLayout

　　　　两个或以上的成员共享同一显示空间，分成多层，每层只允许放置一个组件，可通过panel实现复杂界面。

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

public class ThreePages implements MouseListener {
    CardLayout layout = new CardLayout(); // 初始化一个牌局管理器对象
    Frame f = new Frame("CardLayout");
    Button page1Button;
    Label page2Label;
    TextArea page3Text; // 多行多列的文本区域
    Button page3Top;
    Button Page3Button;

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

    public void go() {
        f.setLayout(layout);
        f.add(page1Button = new Button("Button page"), "page1Button");
        // 第二个参数表示对这层牌所取的名字
        page1Button.addMouseListener(this); // 注册监听器

        f.add(page2Label = new Label("Label page"), "page2Label");
        page2Label.addMouseListner(this);

        Panel panel = new Panel();
        panel.setLayout(new BorderLayout());
        panel.add(page3Text = new TextArea("Composite page"), "Center");
        page3Text.addMouseListner(this);
        panel.add(page3Top = new Button("Top button"), "North");
        page3Top.addMouseListner(this);
        panel.add(Page3Button = new Button("Bottom button"), "South");
        page3Button.addMouseListner(this);
        f.add(panel, "panel");

        f.setSize(200, 200);
        f.setVisible(true);


    }
}

事件

　　步骤：1. 编写监听器类。对于某类事件XXXEvent, 事件源想要接受并处理，需定义相应的监听器类，该类需继承该事件相应接口XXXListener

　　　　　2. 授权。事件源注册该类事件的监听器，使用addXXXListener(XXXLisetner)方法来注册监听器。

eg. button注册Action事件

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

public class TestButton {
    public static void main(String args[]) {
        Frame f = new Frame("Test");
        Button b = new Button("Press Me!");
        b.addActionListener(new ButtonHandler());
        f.setLayout(new FlowLayout());
        f.add(b);
        f.setSize(200, 200);
        f.setVisible(true);
    }
}

class ButtonHandler implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Action occurred");
    }
}

　　AWT共有10类事件，分为两类：低级事件和高级事件

　　　　低级事件：基于容器和组件

　　　　　　ComponentEvent：组件事件，组件的尺寸变化、移动

　　　　　　ContainerEvent：组件增加、移动

　　　　　　WindowEvent: 窗口事件，关闭窗口，窗口闭合，图标化

　　　　　　FocusEvent：焦点事件，焦点的获得和丢失

　　　　　　KeyEvent：键盘事件，键按下、释放

　　　　　　MouseEvent：鼠标事件，鼠标单击、移动

　　　　高级事件：基于语义

　　　　　　ActionEvent：动作事件，按钮按下，TextField中按Enter键

　　　　　　AdjustmentEvent: 调节事件，在滚动条上移动滑块以调节数值

　　　　　　ItemEvent：项目事件，选择项目

　　　　　　TextEvent:  文本事件，文本对象改变

eg. 实现3个监听器事件接口

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

public class ThreeListener implements MouseMotionListener, MouseListener,
       WindowListener {
    private Frame f;
    private TextField tf;

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

    public void go() {
        f = new Frame("Three listner example");
        f.add(new Label("Click and Drag the mouse"), "North");
        tf = new TextField(30);
        f.add(tf, "South");

        f.addMouseMotionListener(this);
        f.addMouseListener(this);
        f.addWindowListener(this);

        f.setSize(300, 200);
        f.setVisible(true);
    }
    // MouseMotionListener接口的实现
    public void mouseDragged(MouseEvent e) {
        String s = "Mousedragging: X=" + e.getX() + "Y=" + e.getY();
        tf.setText(s);
    }

    public void mouseMoved(MouseEvent e) {
    }

    // MouseListener接口的实现
    public void mouseClicked(MouseEvent e) {
    }
        // 鼠标进入时
    public void mouseEntered(MouseEvent e) {
        String s = "the Mouse Entered";
        tf.setText(s);
    }
        // 鼠标离开时
    public void mouseExited(MouseEvent e) {
        String s = "the mouse has left the building";
        tf.setText(s);
    }

    public void mousePressed(MouseEvent e) {
    }

    public void mouseReleased(MouseEvent e) {
    }

    // WindowListener接口的实现
    public void windowOpened(WindowEvent e) {
    }

    public void windowClosed(WindowEvent e) {
    }

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

    public void windowActivated(WindowEvent e) {
    }

    public void windowDeactivated(WindowEvent e) {
    }

    public void windowIconified(WindowEvent e) {
    }

    public void windowDeiconified(WindowEvent e) {
    }
}

事件适配器

　　从以上的例子看出，要实现一个监听器类，当继承相应的接口时，就要实现其所有的方法，尽管很多时候你并不对所有方法都感兴趣。Java提供了一些现有的父类，只要继承就可以，重写需要方法，无关方法不用实现。

java.awt.event包中定义的事件适配器类包括以下几个：

　　ComponentAdapter(组件适配器)

　　ContainerAdapter(容器适配器)

　　FocuAdapter(焦点适配器)

　　KeyAdapter(键盘适配器)

　　MouseAdapter(鼠标适配器)

　　MouseMotionAdapter(鼠标运动适配器)

　　WindowAdapter(窗口适配器)

有两种方法使用适配器

　　使用内部类：内部类可以调用外部类的成员方法和变量，包括私有的成员

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

public class InnerClass {
    private Frame f;
    private TextField tf;

    public InnerClass() {
        f = new Frame("Inner classes example");
        tf = new TextField(30);
    }

    public void launchFrame() {
        Label label = new Label("Click and drog the mouse");
        f.add(label, "North");
        f.add(tf, "South");
        f.addMouseMotionListener(new MyMouseMotionListener());
        f.setSize(300, 200);
        f.setVisible(true);
    }

    class MyMouseMotionListener extends MouseMotionAdapter {
    // 内部类继承MouseMotionAdapter适配器
        public void mouseDragged(MouseEvent e) {
            String s = "Mouse dragging: x=" + e.getX() + "Y=" + e.getY();
            tf.setText(s);
        }
    }

    public static void main(String args[]) {
        InnerClass obj = new InnerClass();
            obj.launchFrame();    
    }
}

　　使用匿名类：也就是此类没有名字。当一个内部类的类声明只是在创建对象时用到，且必须有父类或实现一个接口，才能用匿名类。

　　　　　　　　它只是显示的调用一个无参的父类的构造方法。

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

public class AnonymousClass {
    private Frame f;
    private TextField tf;

    public AnonymousClass() {
        f = new Frame("Inner classes example");
        tf = new TextField(30);
    }

    public void launchFrame() {
        Label label = new Label("Click and drog the mouse");
        f.add(label, "North");
        f.add(tf, "South");
        f.addMouseMotionListener(new MouseMotionAdapter() { // 无参的父类构造函数，匿名类
            public void mouseDragged(MouseEvent e) { 
                String s = "Mouse dragging: x=" + e.getX() + "Y=" + e.getY();
                tf.setText(s);
            }    
        });
        f.setSize(300, 200);
        f.setVisible(true);
    }


    public static void main(String args[]) {
        AnonymousClass obj = new AnonymousClass();
            obj.launchFrame();    
    }
}

几个组件

　　按钮（Button）

　　　　被点击后，产生ActionEvent事件，需ActionListener接口进行监听。

　　　　ActionEvent的对象调用getActionCommand()方法可得到按钮的标识名

　　　　setActionCommand()可以为按钮设置组件标示符

　　复选框(CheckBox)

　　　　提供简单的“on/off”开关，旁边显示文本标签

　　　　构造方法如下：

　　　　　　setLayout(new GridLayout(3, 1));

　　　　　　add(new CheckBox("one", null, true));

　　　　　　add(new CheckBox("two"));

　　　　　　add(new CheckBox("Three"));

　　　　用ItemListner来监听ItemEvent事件

　　　　用getStateChange()获取当前状态

　　　　用getItem()获得被修改复选框的字符串对象

　　复选框组

　　下拉式菜单(Choice)

　　　　Choice Colorchooser = new Choice();

　　　　Colorchooser.add("Green");

　　　　Colorchooser.add("Red");

　　Choice用ItemListener接口来进行监听

　　画布(Canvas)

　　　　要继承Canvas类才能获得有用的功能

　　　　完成图形处理，需重写paint()方法

　　　　监听各种鼠标、键盘事件（即可以注册对应的监听器）

　　　　在Canvas组件中输入字符，需先调用requestFocus()方法

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

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

    public static void main(String args[]) {
        Frame f = new Frame("Canvas");

        MyCanvas mc = new MyCanvas();
        mc.c = new Canvas();

        f.add(mc.c, "Center");

        mc.c.addMouseListener(mc);
        mc.c.addKeyListener(mc);
        f.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) { 
                System.exit(1); 
            }
            }); 
        // 匿名类Adapter

        f.setSize(150, 150);
        f.setVisible(true);
    }
    
    // 实现MouseListener接口
    public void mouseClicked(MouseEvent e) {
        System.out.println("Mouse Clicked");
        c.requestFocus(); // 鼠标点击后获得聚焦
    }

    public void mouseEntered(MouseEvent e) {
        System.out.println("Mouse Entered");
    }

    public void mouseExited(MouseEvent e) {
        System.out.println("Mouse Exited");
    }

    public void mousePressed(MouseEvent e) {
        System.out.println("Mouse Pressed");
    }

    public void mouseReleased(MouseEvent e) {
        System.out.println("Mouse Released");
    }

    // 实现KeyListener接口
    public void keyPressed(KeyEvent e) {
        System.out.println("Key Pressed");
    }

    public void keyReleased(KeyEvent e) {
        System.out.println("Key Releaseed");
    }

    public void keyTyped(KeyEvent e) {
        System.out.println("KeyTyped");
        s += e.getKeyChar(); // 获取每个输入的字符，添加到s
        c.getGraphics().drawString(s, 0, 20); //显示s
    }

}