7. 图形编程 - core java
7.1 Swing概述
Java1.0 包含一个基本的GUI类库. 叫抽象窗口工具箱(AWT). 它是把具体的图形界面交给不同平台去显式.
但由于不同的平台有差异.所以用这个库写的程序只能用这些平台的公共部分. 所以界面也不漂亮.还有bug.
在1996年. Netscape开发了一个和AWT工作方式完全不同的GUI库. 叫英特网基础类库(IFC). 它把用户
界面元素是直接绘制在空白窗口上. 所以这个库写的程序在各个平台上看起来都一样. Sun和Netscape合作
完善了这种方法. 就是Swing库. 它已是Java基础类(JFC)的一部分. 但它的事件处理模型仍使用Java 1.1
的事件处理模型.
使用Swing库就真正做到了一次编写到处运行. 它虽然比AWT慢一些.但现在的机器跑起来已经不成问题.
所以Swing是用户界面的未来. 应该在程序中使用它.
7.2 创建框架
Java中的顶层窗口(即不是包含在其它窗口中)被称作框架.
在AWT库中对应Frame类. 在Swing中对应JFrame类. JFrame从Frame扩展而来.
它是少数几个不绘制在画布上的Swing组件之一. 所以它的修饰部件(按钮.标题栏.图标等)仍是通过用户的
窗口系统绘制.而不是Swing绘制.
框架是一种容器. 可以容纳其它用户界面组件(如按钮等). 它的继承层次为:
Object
|-Component
|-Container
|-JComponent
| |-JPanel
|
|-Widow
|-Frame
|-JFrame
创建框架的代码如下:
import javax.swing.*;
public class SimpleFrameTest {
public static void main(String[] args) {
SimpleFrame frame = new SimpleFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //指定关闭框架时的动作.
frame.show();
}
}
class SimpleFrame extends JFrame {
public SimpleFrame() {
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); //缺省时框架大小是0*0
}
public static final int DEFAULT_WIDTH = 300;
public static final int DEFAULT_HEIGHT = 200;
}
其中javax是个Java1.1扩展包. 而不是核心包.
但是在Java2平台上Swing包已经是核心包而不是扩展包了. 只是为了兼容性javax的名字保留了下来.
7.3 给框架定位
要得到屏幕大小用Toolket类的静态方法getDefaultToolket(). 如下:
Toolkit kit = Toolkit.getDefaultToolkit();
Dimension screenSize = kit.getScreenSize();
int screenWidth = screenSize.width;
int screenHeight = screenSize.height;
给框架指定一个图标:
Image img = kit.getImage("icon.gif"); //先用Toolkit对象载入图标.
frm.setIconimage(img); //为框架设置一个图标.
给框架定位. 可以指定框架的位置和大小(框架的缺省大小为0*0). 用:
public void setBounds(Rectangle r) //同时指定位置和大小
public void setLocation(int x, int y) //指定位置. 坐标为父级坐标系.
要把框架设置为最大尺寸.用:
frm.setExtendedState(Frame.MAXIMIZED_BOTH);
这时Frame类中的方法: public void setExtendedState(int state)
java.awt.Component(组件) 类的一些常用方法:
见笔记 19. java.awt 部件 - Java2详解
java.awt.Window(窗口.即Frame类的父类)的常用方法:
void toFront() //把该窗口显示到其它窗口之前.
void toBack() //把该窗口
java.awt.Frame类的常用方法:
void setResizeable(boolean b) //设置是否允许用户缩放框架
void setTitle(String) //设置框架的标题栏
void setIconImage(Image) //设置框架的图标
void setUndecorated(boolean) //设置是否清除对窗口的修饰
boolean isUndecorated() //返回窗口是否被修饰
int getExtendedState() //获取窗口的状态(是否最大化等).
void setExtendedState(int state) //设置窗口的状态.
java.awt.Toolkit类的常用方法:
static Toolkit getDefaultToolkit() //返回默认的Toolkit
Dimension getScreenSize() //获取屏幕大小
Image getImage(String filename) //加载filename所指定的图像.
7.4 在面板中显示信息
框架JFrame类实际上是组件的容器(可以容纳其它组件).
JFrame中安排了4个窗格. 其中根窗格.布局窗格.透明窗格和内容窗格. 向框架添加组件就是把组件添加到
内容窗格上. 如:
Container contentPane = frm.getContenPane(); //取JFrame的内容窗格对象
Component c = .... ;
contentPane.add(c);
如果框架中只显示一个Swing组件可以用:
JComponent c = .........;
frm.setContentPane(c);
面板JPanel是一个能在其上绘制的表面. 同时也是容器(可以容纳其它组件).
要在JPanel中进行绘制. 需要定义一个类让它扩展JPanel类并覆盖其paintComponent方法:
public void paintComponent(Graphics g) { } //覆盖时其中应调用supper.paintComponent
这样当窗口需要重绘的时候事件处理器会通知组件并执行其paintComponent方法.
但在需要强制重绘屏幕时.你自己不应该调用该方法. 而应该调用repaint方法. repaint会"尽快的"重绘.
注意: 和AWT中不同. Swing中没有了专门的画布(Canvas)类. 而且绘制也不再使用paint方法了.
而且Swing组件使用缓冲进行无抖动绘制.
7.5 2D图形
从SDK2.0开始. J2SE包含了Java 2D库.
使用Java 2D库要先得到 Graphics2D类的对象. Graphics2D是Graphics的子类.
JCompent的paintComponent方法如下:
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g; //如果使用的是启用了Java 2D库的SDK. 则参数g实际上
//就是Graphics2D对象.
}
绘制形状时. 需要先创建一个实现了Shape接口的类的对象. 例如:
Line2D(直线) Rectangle2D(矩形) Ellipse2D(椭圆)
都是实现了Shape接口的类. 绘制时如下:
Rectangle2D rect = ...;
g2.draw(rect);
7.6 颜色
java.awt.Color类提供了13个标准颜色的常量值如 Color.RED 等
例如把组件的背景色设置为红色:
p.setBackground(Color.RED);
要定制RGB颜色值. 用Color的构造器:
Color(int r, int g, int b)
使用如
Graphics g = ..
g.setColor(new Color(0,128,128)); //接着的绘制使用该颜色.
要使颜色变得更亮一点或更暗一点用 brighter() 或 darker().
要用红色填充一个矩形用:
Rectangle2D r = ....
g2.setPaint(Color.RED);
g2.fill(r); //用上边指定的红色填充
7.7 文本和字体
字体就免了. 用的时候再看. 绘制字符串用:
Graphics类的 void drawString(String str, int x, int y)
Graphics2D类的 void drawString(String str, float x, float y)
7.8 图像
要显示图像. 先要读取图像.
读取本地存储的图像.用:
String filename = "...";
Image image = ImageIO.read(new File(filename));
读取网络上的图像文件用:
String filename = "...";
Image image = ImageIO.read(new URL(urlname));
若图像不存在. 则抛出IOException异常.
然后用Graphics的drawImage()方法绘制:
g.drawImage(image, x, y, null);
另外.如果要复制图像(例如用image铺满整个面板就需要复制图像). 用:
g.copy(x, y, imageWidth, imageHeight, x1, x2) //把从(x,y)开始的图像复制到新位置(x1,y1)
在Swing中的组件的绘制都是双缓冲的. 但在AWT中不是. 在AWT中要避免显示时的抖动. 要自己想办法:
Image buffered_image = createImage(width, height);
Graphics bg = buffered_image.getGraphics();
//... //将图像先绘制在缓冲(buffered_image)上.
g.drawImage(buffered_image, 0, 0, null); //再将缓冲区复制到屏幕.
bg.dispose();
buffered_image.flush();
注意g.drawImage()函数. 它的第四个参数是一个观察者.
因为当加载图像时. 图像可能在网络上. 加载比较慢. 为了在加载图像的同时让程序继续向下运行. Java
在这里使用的是多线程的机制来并发运行. 这种机制允许我们跟踪图像的获取过程. 所以当图像的大小确定时.
当新的图像块变得可用时. 图像最终加载完毕时. 我们都会得到通知.
其中drawImage()的第四个参数就是我们指定的接收通知的ImageObserver对象
------------
8. 事件处理 - core java
事件处理包括: 事件源类.事件类.监听器接口.监听器适配器类 它们之间的关系.
其中事件源是用户界面组件.窗口和菜单. 操作系统会把用户的动作通知给感兴趣的事件源. 事件源用一个
事件对象描述所发生事件的特性. 并且. 事件源可以注册一组监听器. 当事件发生时会把事件对象传递给
这些监听器对象. 由监听器对象具体处理发生的事件.
各种事件类的继承层次:
AWTEvent
|
|-ActionEvent
|-AdjustmentEvent
|-ItemEvent
|-TextEvent
|-ComponentEvent
|-ContainerEvent
|-FocusEvent
|-PaintEvent
|-WindowEvent
|-InputEvent
|-KeyEvent
|-MouseEvent
|-MouseWheelEvent
每个事件类都有对应的监听器类. 如ItemEvent类对应的监听器接口ItemListener.监听器接口有:
ActionListener
AdjustmentListener
ComponenListener
ContainerListener
FocusListener
ItemListener
KeyListener
MouseListener
MouseMotionListener
MouseWheelListener
TextListener
WindowListener
WindowFocusListener
WindowStateListener
有的监听器接口中包括多个方法. 为了实现该接口时少写点代码. 提供了一些缺省适配类.
这些缺省适配类为接口中的每个方法提供了默认操作:
ComponentAdapter
ContainerAdapter
FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter
8.3 AWT的语义事件和低层次事件
语义事件是明确表达用户动作的事件.如按下按钮.
低层事件是一些原始的事件.如按下按钮过程中可能会有鼠标左键按下.弹起等.
在java.awt.event包中有:
4个语义事件类
ActionEvent 对应按钮按下. 菜单选择. 列表项选择 或者文本域输入回车.
AdjustmentEvent 对应用户调整了滚动条.
ItemEvent 对应用户从一组选择框或列表项中选择
TextEvent 对应文本域或文本框中的内容发生改变.
6个低层事件类
ComponentEvent 组件被缩放/移动/显示/隐藏 这个类是所有低层次事件类的基类.
KeyEvent 一个键被按下/释放
MouseEvent 鼠标键被按下/释放 鼠标移动/拖动
MouseWheelEvent 鼠标轮被滚动
FocusEvent 组件得到焦点/失去焦点
WindowEvent 窗口被激活/减活/图标化/还原/关闭
ContainerEvent 添加/删除一个组件
8.4 低层事件类型
8.4.1 键盘事件
例如用户同时按下SHIFT和A. 则生成5个事件:
1.按SHIFT事件 2.按A事件 3."输入A"事件 4.释放A事件 5.释放SHIFT事件
监听这些键盘事件需要KeyListener接口. 该接口的方法如下:
void keyPressed(KeyEvent e) //按下
void keyReleased(KeyEvent e) //释放
void keyTyped(KeyEvent e) //键入字符
可以用参数e的 getKeyChar() 或 getKeyCode()来得到键的字符或相关整数(虚拟键代码).
8.4.2 鼠标事件
如果是处理象点击按钮或选择菜单等.则不需要鼠标事件这样的低层事件.
而对于画图等则需要处理这类事件.
鼠标可以产生的事件包括: 按下/释放 单击 进入/离开 移动 拖动 鼠标滚轮旋转 .
有两种事件监听器接口来监听处理MouseEvent.
其中:
接口MouseListener处理: 按下/释放 单击 进入/离开. 它的适配器类为MouseAdapter.
void mouseClicked(MouseEvent e) 单击键时
void mouseEntered(MouseEvent e) 进入组件时
void mouseExited(MouseEvent e) 离开组件时
void mousePressed(MouseEvent e) 按下键时
void mouseReleased(MouseEvent e) 释放键时
接口MouseMotionListener处理: 移动 拖动. 它的适配器类为MouseMotionAdapter.
void mouseDragged(MouseEvent e) 在组件上按下并拖动时
void mouseMoved(MouseEvent e) 移动到组件上但无按键按下时
使用两个监听器接口是为了效率. 因为大多时候我们并不想监听鼠标移动事件.
鼠标事件用MouseEvent类表示(除了鼠标滚轮事件).
类MouseEvent的方法有:
int getButton() 返回事件发生在哪个键上. 返回NOBUTTON BUTTON1 BUTTON2 BUTTON3之一.
int getClickCount() 返回与此事件关联的鼠标单击次数。
Point getPoint() 返回事件相对于源组件的 x、y 位置。
int getX() 返回事件相对于源组件的水平 x 坐标。
int getY() 返回事件相对于源组件的垂直 y 坐标。
String paramString() 返回标识此事件的参数字符串。 调试用.
void translatePoint(int x, int y) 将事件的坐标平移到新位置
另外. MouseEvent继承自 InputEvent类. 所以它继承的方法还有下边的:
public boolean isShiftDown()
public boolean isControlDown()
public boolean isMetaDown()
public boolean isAltDown()
public boolean isAltGraphDown()
public long getWhen()
public int getModifiers()
public int getModifiersEx()
使用这些方法可以知道事件发生时每个鼠标键是否按下.可以知道Shift/Ctrl/Alt等键是否按下.
最后我们还可以更改鼠标光标. 要更改鼠标光标先要加载它. 使用java.awt.Toolkit类的方法:
public Cursor createCustomCursor(Image image, Point hotSpot, String name)
其中参数: image是光标显示时的图像.
hotSpot是光标的坐标(例如可以指定为图像的顶点或图像的中心).
name是光标的说明.
加载光标后用java.awt.Component类的方法:
public void setCursor(Cursor cursor)
来设置光标.
8.4.3 焦点事件
例如文本框得到焦点时就会出现闪烁光标. 而按钮则在按钮标签周围显示矩形等.
同一个窗口中只能有一个组件具有焦点. 组件要得到焦点. 可能是用户点击了它. 也可能是使用Tab键切换的.
在组件得到或失去焦点时会产生FocusEvent事件. 要处理这些事件用监听器:
FocusListener接口(缺省适配器类是FocusAdapter)
它的方法有:
void focusGained(FocusEvent e) 获得键盘焦点
void focusLost(FocusEvent e) 失去键盘焦点
Component关于焦点的方法有:
void requestFocus() 请求把焦点转移到该组件上
void setFocusable(boolean ) 设置是否允许组件获得焦点.
boolean isFocusOwnwer() 检查组件是否已经获得焦点.
8.7 事件队列(core java 第6版)
当操作系统响应用户动作(如鼠标点击)时会生成操作系统事件. AWT把它转换为一个AWTEvent对象. 并添加到
事件队列中. 最后把AWTEvent从事件队列提取出来分派到合适的监听器上.调用监听器上对应的方法.
事件的处理可能需要较长的时间.所以产生的事件不可能立刻就被处理.所以要借助事件队列来缓冲一下.
我们也可以直接操作事件队列. 例如向事件队列中添加/删除事件对象. 这使用下边的函数如:
EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventqQueue(); //取事件队列
queue.postEvent(new ActionEvent(...)); //构造了一个事件并将其添加到事件队列
提取出下一个事件和查看下一个事件使用EventQueue类的方法:
AWTEvent peekEvent(); //查看下一个事件对象 (但不从队列删除)
AWTEvent getNextEvent(); //取出下一个事件对象(并从队列删除)
定制自己的事件类型
本小节我们将定制自己的时间事件并处理它. 定制事件有三个要素:
事件类.
事件监听器接口.
事件源.
首先定义一个自定义事件类TimerEvent. 因为AWT事件队列中的事件必须是AWTEvent类型的. 所以我们这个
TimerEvent要从AWTEvent派生:
class TimerEvent extends AWTEvent {
public TimerEvent(Timer t) { super(t,TIMER_EVENT); } //调用基类的构造方法
//AWTEvent(Object source, int id)用指定的事件源和事件类型构造一个 AWTEvent 对象
public static final int TIMER_EVENT = AWTEvent.RESERVED_ID_MAX+5555;
}
其中构造方法参数中的Timer是我们自己的事件源类. 下边我们定义这个类. 因为AWT事件机制要求事件源要
扩展自Component类. 所以我们的事件源Timer类如下:
class Timer extends JComponent implements Runnable {
private int interval; //定时器事件的间隔时间
private EventListenerList listeners; //用来管理注册的监听器
///
// EventListenerList 类
// 用来管理注册的事件监听器对象. 它的方法包括(下边会用到这些方法):
// void add(Class<T> t, T l) //将监听器作为指定的类型添加
// void remove(Class<T> t, T l) //将监听器作为指定的类型移除
// T[] getListeners(Class<T> t) //返回给定类型的所有侦听器组成的数组
//
public Timer(int i) { //事件源的构造方法.
//它启动了一个线程. 该线程每隔interval时间会向事件队列加入一个
//TimerEvent对象.
interval = i;
Thread t = new Thread(this);
t.start();
}
public void run() {
while (true) {
try { Thread.sleep(interval); }
catch(InterruptedException e) {]
EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
TimerEvent event = new TimerEvent(this); //构造自定义事件并将它放入事件队列
queue.postEvent(event);
}
}
//此时我们已经让TimerEvent事件源源不断的插入AWT事件队列. 不过事情并没有结束. 因为我们
//还要对这些事件进行处理呀. 处理事件是监听器类做的事. 但我们的事件源类要有添加/删除监听器
//的方法. 管理这些监听器对象需要使用 EventListenerList类 . 如下:
public void addTimerListener(TimerListener listener) {
listenerList.add(TimerListener.class, listener);
}
public coid removeTimerListener(TimerListener listener) {
listenerList.romve(TimerListener.class, listener);
}
//当从事件队列中移除事件对象.也就是要处理该事件对象时. 会调用事件源的processEvent方法.
//所以我们的事件源要实现processEvent方法. 这里我们从listenerList中得到TimerListener
//监听器对象的数组. 并调用每个监听器对象的timeElapsed方法.
public void processEvent(AWTEvent event) {
if (event instanceof TimerEvent) {
eventListener[] listeners = listenerList.getListeners(
TimerListener.class);
for (int i=0; i<listeners.length; i++)
((TimerListener)listeners[i]).timeElapsed((TimerEvent)event);
}
else super.processEvent(event);
}
}
//我们要向事件源注册监听器. 下边定义我们的监听器接口
interface TimerListener extends EventLister {
public void timeElapsed(TimerEvent event); //该接口中只声明一个方法
}
这样自定义事件需要的三个类都准备好了. 要使用上边的定时器事件. 可以如下:
Timer timer = new Timer(200);
timer.addTimerListener( new TimerListener() {
public void timeElapsed(TimerEvent event) {
//...
}
});
-----------------
19. java.awt 部件 - Java2详解
19.1 使用java.awt构造图形用户界面
awt包提供的部件的继承层次:
部件
|
|-按钮
|-文本部件
| |-文本域
| |-文本区
|
|-复选框
|-菜单部件
| |-菜单
| |-菜单条
| |-菜单项
|
|-容器
|-面板
| |-小应用程序
|
|-窗口
|-框架
|-对话框
19.2 按钮 Button
创建按钮:
有带标签和不带标签两个构造方法
public Button();
public Button(String lable);
设置/读取按钮的标签:
public void setLable(String)
public String getLable()
处理按钮消息
处理Java中的事件有两种办法.
在Java 1.0事件模式中.所有部件都有一个名为action的方法.当部件上有动作时.系统就调用action方法.
但这种事件处理方式不好. 所以已经将 action 方法标记为将要从API中删除的方法.
// 例子: 用action方法处理按钮事件.
import java.applet.*;
import java.awt.*;
public class ButtonApplet extends Applet {
public void init() {
add(new Button("Red"));
add(new Button("Blue"));
}
public boolean action(Event evt, Object whatAction) {
if (!(evt.target instanceof Button)) {
return false;
}
String buttonLabel = (String)whatAction;
if (buttonLabel == "Red") {
setBackground(Color.red);
}
else if (buttonLabel == "Blue") {
setBackground(Color.blue);
}
repaint();
return true;
}
}
另一种事件处理方式是使用Java 1.1版的事件模式. 这是使用监听器和适配器的模式. 如下:
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
// 一个操作事件(即语意上的事件)的监听器类.
// 当他监听的对象有事件发生时会通知他. 调用actionPerformed方法.
public class BGSetter extends Object implements ActionListener {
Component component;
Color color;
public BGSetter(Component component, Color color) {
this.component = component;
this.color = color;
}
public void actionPerformed(ActionEvent evt) {
component.setBackground(color);
component.repaint();
}
}
// ActionListener接口
// 其中的ActionListener接口是用于接收操作事件(即语意事件)的侦听器接口。
// 该接口只有一个方法 void actionPerformed(ActionEvent e) .
// 对处理操作事件感兴趣的类可以实现此接口，然后用 addActionListener
// 方法把该监听器对象向某个组件注册。在组件上发生操作事件时，就会调用该监听器对象的
// actionPerformed 方法。 该方法的参数ActionEvent e 是组件上产生的语意事件对象.
// 所谓语意事件是指高级别的事件. 例如按钮的按下事件等. 而不是鼠标单击这样的低级事件.
//
/
// ActionEvent类
// public class ActionEvent extends AWTEvent
// 构造器:
// public ActionEvent(Object source, int id, String command)
// public ActionEvent(Object source, int id, String command, int modifiers)
// public ActionEvent(Object source, int id, String command,
// long when, int modifiers)
// 其中: source 是发起事件的源对象. id是标识事件的整数. command是与事件相关的命令.
// modifiers是发生此动作时按下的组合键. when是发生事件的时间.
// ActionEvent类的其他方法有:
// public String getActionCommand() //返回标识此事件命令的字符串
// public long getWhen() //返回此事件的时间戳
// public int getModifiers() //返回事件发生时按下的组合键
/
// 创建了按钮后. 向按钮注册一个监听器.
import java.applet.*;
import java.awt.*;
public class Button2Applet extends Applet {
public void init() {
Button red = new Button("Red");
add(red);
red.addActionListener(new BGSetter(this, Color.red));
Button blue = new Button("Blue");
add(blue);
blue.addActionListener(new BGSetter(this, Color.blue));
}
}
19.4 标签 Label
创建标签
public Label() //空标签
public Label(String) //指定标签上的文字
public Label(String, int) //后边的int参数是对齐方式.如 Label.LEFT是左对齐.
设置/读取标签上的文本:
public void setText(String)
public String getText()
设置/读取标签上文字的对齐方式:
public void setAlignment(int) throws IllegalargumentException
public int getAlignment()
19.5 复选框和单选按钮 Checkbox
复选框和单选按钮很相似. 只是它们一个可以多选.一个只能单选.
单选按钮是复选框的特例.创建的时候把一组复选框放在同一个复选框组中就创建了一套单选按钮.
Checkbox类实现了 ItemSelectable 接口.
///
// ItemSelectable 接口
// 这个接口是"可选择项"的对象的接口. 它声明了下边几个方法:
// Object[] getSelectedObjects() //返回选定项.如果没有选定的项则返回 null
// void addItemListener(ItemListener l) //添加"项事件"侦听器l
// void removeItemListener(ItemListener l) //移除"项事件"侦听器l
///
/
// ItemListener接口
// "项事件"侦听器类是自己写的类. 它要实现 java.awt.Event.ItemListener接口.
// 而该接口有一个唯一的方法:
// void itemStateChanged(ItemEvent)
// 给某个组件添加了该侦听器后. 当用户更改组件产生组件的"项事件"(即选择或取消选择)时. 调用侦听器
// 对象的 itemStateChanged(ItemEvent) 方法. (如果是程序中更改组件的状态.则不发送项事件.)
// 而 itemStateChanged 方法的参数 ItemEvent 就是"项事件"的类.
/
//
// ItemEvent类
// ItemEvent也是"语意上的事件". 当用户改变ItemSelectable对象(例如Checkbox)时会产生该事件.
// 然后该事件会被传递到每个注册了的侦听器对象上进行处理.
// ItemEvent类的方法如下:
// 构造方法:
// ItemEvent(ItemSelectable source, int id, Object item, int stateChange)
// 参数分别为 产生事件的源. 标识事件类型的id. 受该事件影响的项. 是选择/取消选择
// 其它方法:
// public ItemSelectable getItemSelectable() //返回产生此事件的源对象
// public Object getItem() //返回受事件影响的项。
// public int getStateChange() //返回状态更改的类型（已选定或已取消选定）。
///
创建复选框:
public Checkbox() //无标签的复选框
public Checkbox(String label) //带标签的复选框
public Checkbox(String label, boolean state) //带标签和初始状态(true为选中)的复选框
检查/设置复选框的选中状态.
public boolean getState()
public void setState(boolean)
查看/设置复选框的标签.
public String getLabel()
public void setLabel(String label)
监听复选框中的变化.
和按钮的事件处理类似. Checkbox类用下边两个方法添加/删除监听器:
addItemListener(ItemListener)
removeItemListener(ItemListener)
//下边的例子示例了Checkbox事件的处理:
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class CheckboxExample extends Applet {
public void init() {
Checkbox redBlue = new Checkbox("Red/Blue");
add(redBlue);
redBlue.addItemListener( new ItemListener(){ //监听器类是个内制类.
public void itemStateChanged(ItemEvent evt){ //实现了接口中唯一的方法
if (evt.getStateChange() == ItemEvent.SELECTED)
setColor(Color.red);
else
setColor(Color.blue);
}
} );
}
public void setColor(Color color) {
setBackground(color);
repaint();
}
}
创建单选按钮:
要创建单选按钮要先创建复选框组. 复选框组的构造函数为:
public CheckboxGroup()
在用它的对象作参数创建单选按钮:
public Checkbox(String label, boolean initialState, CheckboxGroup group)
public Checkbox(String label, CheckboxGroup group, boolean initialState)
这两个函数就可以创建互斥的单选按钮组. 组中的最后一个初时状态为true的单选按钮会被初始为选择状态.
取得单选按钮的组用:
public CheckboxGroup getCheckboxGroup()
对于复选框组(CheckboxGroup)的对象. 可以调用下边的方法检查/设置组中一个单选按钮是否选中:
public Checkbox getSelectedCheckbox()
void setSelectedCheckbox(Checkbox box)
19.6 选择框 Choice
选择框(就是下拉式列表)也实现了 ItemSelectable 接口.
构造函数:
Choice()
其它函数:
public int getItemCount() //返回此 Choice 菜单中项的数量。
public String getItem(int index) //获得此 Choice 菜单中指定索引上的字符串。
public void add(String item) //添加一个项。
public void insert(String item, int index) //将菜单项插入指定位置. 索引从0开始.
public void remove(int position) //移除指定的项.
public void remove(String item) //移除第一个item。
//如果正被移除的项是目前选定的项，则该选择中的第一个项将成为选定项。
public void removeAll() //移除所有的项。
public String getSelectedItem() //获得当前选择的字符串表示形式
public Object[] getSelectedObjects() //返回包含当前选定项的数组(长度为 1)
public int getSelectedIndex() //返回当前选定项的索引
public void select(int pos) //选定指定位置上的项
public void select(String str) //选定str的项. 如果有多个同名的. 则选索引值最小的那个.
public void addItemListener(ItemListener l) //添加项侦听器
public void removeItemListener(ItemListener l) //移除项侦听器
public ItemListener[] getItemListeners() //返回已注册的所有项侦听器的数组
public <T extends EventListener> T[] getListeners(Class<T> listenerType) //不懂
protected void processEvent(AWTEvent e) //不懂
protected void processItemEvent(ItemEvent e) //不懂
19.7 列表框 List
列表框也实现了ItemSelectable接口. 其中的值可以单选. 也可以多选.
当用户选中或取消选中某项时，AWT 将向 List 送一个 ItemEvent 实例。
当用户双击滚动列表中的某一项时，AWT 会在紧随 ItemEvent 后向 List 发送一个 ActionEvent 实例
当用户选中List的某项，按下 return 键时，AWT 也将生成一个 ActionEvent。
构造方法:
public List() //默认构造器. 单选. 可见4行.
public List(int rows) // 单选 . 可见 rows 行.
public List(int rows, boolean multipleMode) //若multipleMode为true则是多选.
其它方法:
public int getItemCount() //获取List中的项数
public String getItem(int index) //获取索引index的项
public String[] getItems() //获取所有的项
public void add(String item) //向末尾添加项
public void add(String item, int index) //向指定位置添加项
public void replaceItem(String newValue, int index) //替换指定位置上的项
public void removeAll() //移除所有项
public void remove(String item) //移除该项的第一次出现
public void remove(int position) //移除指定位置的项
public int getSelectedIndex() //获取选中的项的索引
public String getSelectedItem() //获取选中的项
public int[] getSelectedIndexes() //获取所有选中项的索引数组
public String[] getSelectedItems() //获取所有选中项的数组
public Object[] getSelectedObjects() //获取选中项的数组. 声明于ItemSelectable 接口
public void select(int index) //选择指定索引处的项
public void deselect(int index) //取消选择指定索引处的项
public boolean isIndexSelected(int index) //检查是否选定index项
public int getRows() //获取可视行数
public boolean isMultipleMode() //是否允许多选?
public void setMultipleMode(boolean b) // 设置是否允许多选.
public void makeVisible(int index) //使指定索引处的项可视
public int getVisibleIndex() //获取上次由 makeVisible 方法使其可视的项的索引
public Dimension getPreferredSize(int rows) //获取具有指定行数的列表的首选维数
public Dimension getMinimumSize(int rows) //获取具有指定行数的列表的最少维数
public Dimension getPreferredSize() //获取此滚动列表的首选大小
public Dimension getMinimumSize() //获取此滚动列表的最小大小
public void addItemListener(ItemListener l) //添加"项侦听器"
public void removeItemListener(ItemListener l) //移除"项侦听器"
public ItemListener[] getItemListeners() //返回已在此List上注册的所有项侦听器的数组
public void addActionListener(ActionListener l) //添加 Action侦听器(如双击某项)
public void removeActionListener(ActionListener l) //移除 Action侦听器
public ActionListener[] getActionListeners() //返回已注册的所有操作侦听器的数组
public <T extends EventListener> T[] getListeners(Class<T> listenerType) //不懂
protected void processEvent(AWTEvent e) //不懂
protected void processItemEvent(ItemEvent e) //不懂
protected void processActionEvent(ActionEvent e) //不懂
19.8 文本域和文本区 TextField 和 TextArea
即单行文本和多行文本. 两个类都派生自 TextComponent类.
TextComponent类中的方法如下:
public void enableInputMethods(boolean enable) //启用或禁用此方法的输入方法支持
public InputMethodRequests getInputMethodRequests() //获得输入方法请求处理程序
public void setText(String t) //设置文本。
public String getText() //返回文本
public boolean isEditable() //是否可编辑?
public void setEditable(boolean b) //设置是否可编辑
public Color getBackground() //获得此文本组件的背景色
public void setBackground(Color c) //设置此文本组件的背景色
public int getSelectionStart() //获取选定文本的开始位置
public void setSelectionStart(int selectionStart) //设置选定文本的开始位置
public int getSelectionEnd() //获取选定文本的结束位置
public void setSelectionEnd(int selectionEnd) //设置选定文本的结束位置
public void select(int selectionStart, int selectionEnd) //选择一段文本
public void selectAll() //选择所有文本
public void setCaretPosition(int position) //设置文本插入符的位置
public int getCaretPosition() //返回文本插入符的位置
public void addTextListener(TextListener l) //添加文本事件侦听器
public void removeTextListener(TextListener l) //移除指定的文本事件侦听器
public TextListener[] getTextListeners() //返回所有已注册文本侦听器的数组
public <T extends EventListener> T[] getListeners(Class<T> listenerType) //不懂
protected void processEvent(AWTEvent e) //不懂
protected void processTextEvent(TextEvent e) //不懂
文本域
创建文本域(TextField)
public TextField()
public TextField(String text) //指定初始文本
public TextField(int columns) //指定列数. 列是近似平均字符宽度.与平台有关.
public TextField(String text, int columns) //同时指定二者.
其它方法:
public char getEchoChar() //获取回显字符(输入密码时显示的). 若为0则正常显示用户输入.
public void setEchoChar(char c) //设置此文本字段的回送字符
public void setText(String t) //设置文本
public boolean echoCharIsSet() //是否有一个回送字符集?
public int getColumns() //获取列数
public void setColumns(int columns) //设置列数
public Dimension getPreferredSize(int columns) //获取具有指定列数的文本字段的首选大小
public Dimension getPreferredSize() //获取此文本字段的首选大小
public Dimension getMinimumSize(int columns) //获取具有指定列数的文本字段的最小尺寸
public Dimension getMinimumSize() //获取此文本字段的最小尺寸
public void addActionListener(ActionListener l) //添加Action侦听器(按回车键产生事件)
public void removeActionListener(ActionListener l) //移除Action侦听器
public ActionListener[] getActionListeners() //返回已注册的Action侦听器的数组
public <T extends EventListener> T[] getListeners(Class<T> listenerType) //不懂
protected void processEvent(AWTEvent e) //不懂
protected void processActionEvent(ActionEvent e) //不懂
文本区
构造方法:
public TextArea() //缺省的.初始时没有文本. 带垂直/水平滚动条.
public TextArea(String text)
public TextArea(int rows, int columns) //指定行数和列数
public TextArea(String text, int rows, int columns)
public TextArea(String text, int rows, int columns, int scrollbars)
其中: text是初始文本. rows/columns是行列数. scrollbars是指定显示什么滚动条.可以使用常量:
SCROLLBARS_BOTH, SCROLLBARS_VERTICAL_ONLY,
SCROLLBARS_HORIZONTAL_ONLY, SCROLLBARS_NONE
其它方法:
public void insert(String str, int pos) //指定位置插入指定文本
public void append(String str) //将str追加到文本区的当前文本
public void replaceRange(String str, int start, int end) //替换某区间的文本
public int getRows() //这4个函数查看/设置行列数
public void setRows(int rows)
public int getColumns()
public void setColumns(int columns)
public int getScrollbarVisibility() //查看使用何种滚动条的枚举值
public Dimension getPreferredSize(int rows, int columns) //返回具有指定行列数的首选大小
public Dimension getPreferredSize() //确定此文本区的首选大小
public Dimension getMinimumSize(int rows, int columns) //返回具有指定行列数的最小大小
public Dimension getMinimumSize() //返回此文本区的最小大小
19.9 滚动条 Scrollbar
Scrollbar 实现了 Adjustable 接口.
//
// Adjustable接口
// 就是可以调整整数值的接口. 声明的方法如下:
// int getOrientation() //获得此可调整对象的定向性(即方向性).
// //返回值可以是常量HORIZONTAL、VERTICAL 或者 NO_ORIENTATION
// void setMinimum(int min) //查看/设置可调整对象的最小值和最大值
// int getMinimum()
// void setMaximum(int max)
// int getMaximum()
// void setUnitIncrement(int u) //设置/查看 可调整对象的单位值增量
// int getUnitIncrement()
// void setBlockIncrement(int b) //设置/查看 可调整对象的块值增量
// int getBlockIncrement()
// void setVisibleAmount(int v) //设置/查看 可调整对象的比例指示器的长度
// int getVisibleAmount()
// void setValue(int v) //设置/查看 可调整对象的当前值
// int getValue()
// void addAdjustmentListener(AdjustmentListener l) //添加侦听器.在值更改时处理调整事件
// void removeAdjustmentListener(AdjustmentListener l) //移除一个调整侦听器
///
// AdjustmentListener接口
// Adjustable添加/移除侦听器的方法的参数是AdjustmentListener接口的对象. 该接口只有一个方法:
// void adjustmentValueChanged(AdjustmentEvent e)
// 其中 AdjustmentEvent 是调整事件的类.
///
// AdjustmentEvent 类
// 构造方法:
// public AdjustmentEvent(Adjustable source, int id, int type, int value)
// public AdjustmentEvent(Adjustable source,
// int id, int type, int value, boolean isAdjusting)
// source为事件源. id是事件类型. type是调整类型. value是当前的调整值.
// isAdjusting-如果事件是连续多个调整事件之一，则该参数为 true.
// 其它方法:
// public Adjustable getAdjustable() //返回发起此事件的 Adjustable 对象
// public int getValue() //返回调整事件中的当前值
// public int getAdjustmentType() //返回导致值更改事件的调整类型。它将是以下常量之一：
// UNIT_INCREMENT //单位增量调整类型
// UNIT_DECREMENT //单位减量
// BLOCK_INCREMENT //块增量
// BLOCK_DECREMENT //块减量
// TRACK //绝对跟踪调整类型
// public boolean getValueIsAdjusting() //是否此事件是多个调整事件之一?
/
Scrollbar构造方法:
public Scrollbar()
public Scrollbar(int orientation) //参数指出滚动条是水平还是垂直的
public Scrollbar(int orientation, int value,
int visible, int minimum, int maximum)
其中参数:
orientation - 指示滚动条的方向。 缺省为Scrollbar.VERTICAL 垂直
value - 滚动条的初始值 缺省为0.
visible - 滚动条的可视量，通常由滑动块的大小表示. 缺省为10
minimum - 滚动条的最小值 缺省为0
maximum - 滚动条的最大值 缺省为100
Scrollbar的其它方法:
public void setValues(int value,int visible,int minimum,int maximum) //参数同构造器
public AdjustmentListener[] getAdjustmentListeners() //返回所有已注册调整侦听器的数组
public <T extends EventListener> T[] getListeners(Class<T> listenerType) //不懂
protected void processEvent(AWTEvent e) //不懂
protected void processAdjustmentEvent(AdjustmentEvent e) //不懂
以及接口Adjustable中声明的方法.
19.10 画布 Canvas
Canvas组件表示屏幕上一个空白矩形区域. 程序可以在该区域内画图. 或从该区域捕获用户输入事件.
应用程序必须为 Canvas 类创建子类，以获得有用的功能（如创建自定义组件）。必须重写 paint 方法，以便
在 canvas 上执行自定义图形。
不懂........
19.11 部件的公共方法 Component
所有的awt部件都从它派生. 它定义了下边的方法:
public String getName() //查看/设置 组件的名称
public void setName(String name)
public Container getParent() //获得此组件的父级容器
public boolean isValid() //确定组件是否有效
public Point getMousePosition() throws HeadlessException //如果此 Component
//正好位于鼠标指针下，则返回鼠标指针在 Component 的坐标空间中的位置；否则返回 null
public boolean isShowing() //确定此组件是否在屏幕上显示
public boolean isEnabled() //确定此组件是否已启用。已启用的组件可以响应用户输入并生成事件
public void setEnabled(boolean b) //启用或禁用此组件.初始时是启用的
public boolean isDoubleBuffered() //如果将此组件支持双缓冲绘制则返回true.默认返回false
//所以如果自己的组件子类支持双缓冲绘制.应该重写此方法让它返回 true。
public void enableInputMethods(boolean enable) //启用或禁用输入法支持.
public Color getForeground() //获得组件的前景色.如果此组件没有前景色，则返回其父级的前景色
public void setForeground(Color c) //设置组件的前景色. 若参数为null则继承父级的前景色
public boolean isForegroundSet() //返回是否已为此组件显式地设置了前景色
public Color getBackground() //获得组件的背景色. 若无.则返回父级的背景色
public void setBackground(Color c) //设置组件的背景色。若参数为null则继承父级的背景色
public boolean isBackgroundSet() //返回是否已为此组件显示地设置了背景色
public Font getFont() //获得组件的字体。若无.则返回父级的字体
public void setFont(Font f) //设置组件的字体.若参数为null则继承父级的字体
public boolean isFontSet() //返回是否已为此组件显示地设置了字体
public Locale getLocale() //获得组件的语言环境.若无.则返回父级的语言环境
public void setLocale(Locale l) //设置组件的语言环境
public ColorModel getColorModel() //返回组件使用的颜色模型
public Point getLocation() //获得组件的位置(组件左上角的点).该位置是相对于父级坐标空间的
public Point getLocationOnScreen() //获得组件的位置(屏幕坐标空间中组件左上角的点)
public void setLocation(int x, int y) //将组件移到新位置(相对父级坐标)
public void setLocation(Point p) //将组件移到新位置(相对父级坐标)
public Dimension getSize() //返回组件的大小(宽和高)
public void setSize(int width, int height) //设置组件大小
public void setSize(Dimension d)
public Rectangle getBounds() //返回表示组件边界的 Rectangle(包括宽高和位置)
public void setBounds(int x, int y, int width, int height) //设置边界
public void setBounds(Rectangle r)
public int getX() //返回组件原点的当前 x 坐标(相对父级坐标)
public int getY()
public int getWidth()
public int getHeight()
public boolean isLightweight() //如果组件有一个轻量同位体，则返回 true
public void setPreferredSize(Dimension preferredSize)//设置首选尺寸.参数null表示默认值
public boolean isPreferredSizeSet() //如果已将首选大小设置为非 null 值，则返回 true
public Dimension getPreferredSize() //获得组件的首选大小
与首选尺寸类似. 还有组件的最大尺寸和最小尺寸相关的方法. 这里省略.
public float getAlignmentX() //返回 x 轴的对齐方式。值该是 0 到 1 之间的数.
// 其中 0 代表与原点对齐，1 代表距离原点最远处对齐，0.5 代表居中等
public float getAlignmentY() // x 轴的对齐方式 . 和上边类似
public void doLayout() //提示布局管理器布局此组件
public void validate() //确保组件具有有效的布局
public void invalidate() //使此组件无效
public Graphics getGraphics() //为组件创建一个图形上下文.若组件当前不可显示.返回null
public FontMetrics getFontMetrics(Font font) //获得指定字体的字体规格
public void setCursor(Cursor cursor) //设置光标图像
public void paint(Graphics g) //绘制此组件
public void update(Graphics g) //更新组件
public void paintAll(Graphics g) //绘制此组件及其所有子组件
public void repaint() //尽快重绘此组件
public void repaint(long tm) //在指定时间内重绘
public void repaint(int x, int y, int width, int height) //尽快重绘这个区域
public void repaint(long tm, int x, int y, int width, int height)
public void print(Graphics g) //打印此组件. 此方法的默认实现调用 paint 方法
public void printAll(Graphics g) //打印此组件及其所有子组件
public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h)
//图像已改变时重绘组件. 声明于接口 ImageObserver
public Image createImage(ImageProducer producer) //由指定的图像生成器创建一幅图像
public Image createImage(int width, int height)创建一幅用于双缓冲的、可在屏幕外绘制的图像
public VolatileImage createVolatileImage(int width, int height)
//创建一幅用于双缓冲的、可变的、可在屏幕外绘制的图像。
public VolatileImage createVolatileImage(int width, int height,
ImageCapabilities caps) //创建一幅具有给定容量的、可变的、可在屏幕外绘制的图像
public boolean prepareImage(Image image, ImageObserver observer)
//准备一幅在此组件上呈现的图像。图像数据由另一个线程异步下载并生成适当的图像屏幕表示
public boolean prepareImage(Image image, int width, int height,
ImageObserver observer) //以指定的宽度和高度准备一幅在在此组件上呈现的图像。
public int checkImage(Image image, ImageObserver observer)
//返回指定图像屏幕表示的构造状态
public int checkImage(Image image, int width, int height,
ImageObserver observer)
public boolean contains(int x, int y) //组件是否“包含”指定的点(相对组件坐标)?
public boolean contains(Point p)
public Component getComponentAt(int x, int y) //确定此组件或其直接子组件之一是否包含
（x，y）位置，并且如果是，则返回包含该位置的组件。此方法仅查找一层子组件。
public Component getComponentAt(Point p) //返回包含指定点的组件或子组件
public final void dispatchEvent(AWTEvent e) //为组件或其子组件之一指派事件。
对于已为 Component 启用的 1.1 类型的事件，在返回前要调用 processEvent
public void addComponentListener(ComponentListener l) //添加指定的组件侦听器
public void removeComponentListener(ComponentListener l) //移除指定的组件侦听器
public ComponentListener[] getComponentListeners() //返回所有已注册的组件侦听器的数组
public void addFocusListener(FocusListener l) //添加指定的焦点侦听器
public void removeFocusListener(FocusListener l) //移除指定的焦点侦听器
public FocusListener[] getFocusListeners() //返回在此组件上所有已注册的焦点侦听器的数组
public void addHierarchyListener(HierarchyListener l) //添加指定的层次结构侦听器
public void removeHierarchyListener(HierarchyListener l) //移除指定的层次结构侦听器
public HierarchyListener[] getHierarchyListeners() //返回所有已注册层次结构侦听器的数组
public void addHierarchyBoundsListener(HierarchyBoundsListener l)
public void removeHierarchyBoundsListener(HierarchyBoundsListener l)
public HierarchyBoundsListener[] getHierarchyBoundsListeners()
public void addKeyListener(KeyListener l) //添加指定的按键侦听器
public void removeKeyListener(KeyListener l) //移除指定的按键侦听器
public KeyListener[] getKeyListeners()
public void addMouseListener(MouseListener l)
public void removeMouseListener(MouseListener l)
public MouseListener[] getMouseListeners()
public void addMouseMotionListener(MouseMotionListener l) //添加指定的鼠标移动侦听器
public void removeMouseMotionListener(MouseMotionListener l)
public MouseMotionListener[] getMouseMotionListeners()
public void addMouseWheelListener(MouseWheelListener l) //添加指定的鼠标轮侦听器
//容器还接收子组件发出的鼠标轮事件
public void removeMouseWheelListener(MouseWheelListener l)
public MouseWheelListener[] getMouseWheelListeners()
public void addInputMethodListener(InputMethodListener l) //添加输入法侦听器
public void removeInputMethodListener(InputMethodListener l)
public InputMethodListener[] getInputMethodListeners()
public InputMethodRequests getInputMethodRequests() //获得输入方法请求处理程序
public InputContext getInputContext() //获得此组件使用的输入上下文
public <T extends EventListener> T[] getListeners(Class<T> listenerType)
返回一个当前在此 Component 上作为 XXXListener 注册的所有对象的数组。
XXXListener 是用 addXXXListener 方法注册的。如返回鼠标侦听器的数组用:
MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));
protected final void enableEvents(long eventsToEnable) //启用事件(事件类型由参数指定)
protected final void disableEvents(long eventsToDisable) //禁用事件
protected AWTEvent coalesceEvents(AWTEvent existingEvent,
AWTEvent newEvent)将加入的事件与已有的事件组合在一起。
protected void processEvent(AWTEvent e) //处理在组件上发生的事件。
//默认情况下，此方法调用给定事件类型的相应 process<event type>Event 方法
protected void processComponentEvent(ComponentEvent e)
//处理组件上发生的组件事件，方法是将其指派到任意已注册的 ComponentListener 对象
与上个方法类似有:
protected void processFocusEvent(FocusEvent e)
protected void processKeyEvent(KeyEvent e)
protected void processMouseEvent(MouseEvent e)
protected void processMouseMotionEvent(MouseEvent e)
protected void processMouseWheelEvent(MouseWheelEvent e)
protected void processInputMethodEvent(InputMethodEvent e)
protected void processHierarchyEvent(HierarchyEvent e)
protected void processHierarchyBoundsEvent(HierarchyEvent e)
public boolean isFocusable() //返回此 Component 是否可以获得焦点
public void setFocusable(boolean focusable) //参数表明此 Component 是否可以获得焦点
public void requestFocus() //请求此 Component 获得输入焦点
public void transferFocus() //将焦点转移到下一个组件，就好像此 Component 曾是焦点所有者
public void transferFocusBackward() //将焦点转移到前一个组件，就好像它曾是焦点所有者
public boolean isFocusOwner() //是否是焦点所有者
public void add(PopupMenu popup)向组件添加指定的弹出菜单
public void remove(MenuComponent popup)从组件移除指定的弹出菜单
public void list()将组件列表打印到标准系统输出流 System.out
6579
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
