日期：2011-03-22 16:16:00 来源：本站整理
再探早期示例[Java编程]
本文“再探早期示例[Java编程]”是由七道奇为您精心收集，来源于网络转载，文章版权归文章作者所有，本站不对其观点以及内容做任何评价，请读者自行判断，以下是其具体内容：
为注意到一些操纵新事件模子的例子和为学习程序从纯熟新事件模子改变的办法,下面的例子回到在本章第一部份操纵事件模子来证明的一些争议.别的,每个程序包含程序片和利用程序目前都可以借助或不借助浏览器来运行.
1. 文本字段
这个例子同TextField1.java类似,但它增添了明显额外的行为:
//: TextNew.java
// Text fields with Java 1.1 events
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class TextNew extends Applet {
Button
b1 = new Button("Get Text"),
b2 = new Button("Set Text");
TextField
t1 = new TextField(30),
t2 = new TextField(30),
t3 = new TextField(30);
String s = new String();
public void init() {
b1.addActionListener(new B1());
b2.addActionListener(new B2());
t1.addTextListener(new T1());
t1.addActionListener(new T1A());
t1.addKeyListener(new T1K());
add(b1);
add(b2);
add(t1);
add(t2);
add(t3);
}
class T1 implements TextListener {
public void textValueChanged(TextEvent e) {
t2.setText(t1.getText());
}
}
class T1A implements ActionListener {
private int count = 0;
public void actionPerformed(ActionEvent e) {
t3.setText("t1 Action Event " + count++);
}
}
class T1K extends KeyAdapter {
public void keyTyped(KeyEvent e) {
String ts = t1.getText();
if(e.getKeyChar() ==
KeyEvent.VK_BACK_SPACE) {
// Ensure it's not empty:
if( ts.length() > 0) {
ts = ts.substring(0, ts.length() - 1);
t1.setText(ts);
}
}
else
t1.setText(
t1.getText() +
Character.toUpperCase(
e.getKeyChar()));
t1.setCaretPosition(
t1.getText().length());
// Stop regular character from appearing:
e.consume();
}
}
class B1 implements ActionListener {
public void actionPerformed(ActionEvent e) {
s = t1.getSelectedText();
if(s.length() == 0) s = t1.getText();
t1.setEditable(true);
}
}
class B2 implements ActionListener {
public void actionPerformed(ActionEvent e) {
t1.setText("Inserted by Button 2: " + s);
t1.setEditable(false);
}
}
public static void main(String[] args) {
TextNew applet = new TextNew();
Frame aFrame = new Frame("TextNew");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(300,200);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
当TextField t1的行动接纳器被激活时,TextField t3就是一个需求报告的场所.我们注意到仅当我们按下“enter”键时,行动接纳器才会为“TextField”所激活.
TextField t1附有几个接纳器.T1接纳器从t1复制全部文字到t2,强迫全部字符串转换成大写.我们会发现这两个工作同是举行的,并且假如我们增添T1K接纳器后我们再增添T1接纳器,它就不那么重要:在文字字段内的全部的字符串将一向被强迫变成大写.这看起来键盘事件一向在文字组件事件前被激活,并且假如我们需求保存t2的字符串本来输入时的模样,我们就必须做一些分外的工作.
T1K有着别的的一些风趣的活动.我们必须测试backspace（因为我们目前掌握着每一个事件）并履行删除.caret必须被明确地设置到字段的末尾;不然它不会像我们但愿的运行.最后,为了避免本来的字符串被默许的机制所处理,事件必须操纵为事件对象而存在的consume()办法所“耗尽”.这会告诉系统终止激活别的特别事件的事件处理器.
这个例子一样无声地证明了计划内部类的带来的诸多长处.注意下面的内部类:
class T1 implements TextListener {
public void textValueChanged(TextEvent e) {
t2.setText(t1.getText());
}
}
t1和t2不属于T1的一部份,并且到目前为止它们都是很简单理解的,没有任何的特别限制.这是因为一个内部类的对象能自动地捕捉一个句柄到外部的成立它的对象那边,因此我们可以处理封装类对象的办法和内容.正像我们看到的,这非常便利（注释⑥）.
⑥:它也办理了“回调”的问题,没必要为Java加入任何令人恼火的“办法指针”特点.
2. 文本区域
Java 1.1版中Text Area最重要的改变就转动条.关于TextArea的构建器而言,我们可以当即掌握TextArea能否会拥有转动条:水平的,垂直的,二者都有大概都没有.这个例子改正了前面Java 1.0版TextArea1.java程序片,演示了Java 1.1版的转动条构建器:
//: TextAreaNew.java
// Controlling scrollbars with the TextArea
// component in Java 1.1
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class TextAreaNew extends Applet {
Button b1 = new Button("Text Area 1");
Button b2 = new Button("Text Area 2");
Button b3 = new Button("Replace Text");
Button b4 = new Button("Insert Text");
TextArea t1 = new TextArea("t1", 1, 30);
TextArea t2 = new TextArea("t2", 4, 30);
TextArea t3 = new TextArea("t3", 1, 30,
TextArea.SCROLLBARS_NONE);
TextArea t4 = new TextArea("t4", 10, 10,
TextArea.SCROLLBARS_VERTICAL_ONLY);
TextArea t5 = new TextArea("t5", 4, 30,
TextArea.SCROLLBARS_HORIZONTAL_ONLY);
TextArea t6 = new TextArea("t6", 10, 10,
TextArea.SCROLLBARS_BOTH);
public void init() {
b1.addActionListener(new B1L());
add(b1);
add(t1);
b2.addActionListener(new B2L());
add(b2);
add(t2);
b3.addActionListener(new B3L());
add(b3);
b4.addActionListener(new B4L());
add(b4);
add(t3); add(t4); add(t5); add(t6);
}
class B1L implements ActionListener {
public void actionPerformed(ActionEvent e) {
t5.append(t1.getText() + "\n");
}
}
class B2L implements ActionListener {
public void actionPerformed(ActionEvent e) {
t2.setText("Inserted by Button 2");
t2.append(": " + t1.getText());
t5.append(t2.getText() + "\n");
}
}
class B3L implements ActionListener {
public void actionPerformed(ActionEvent e) {
String s = " Replacement ";
t2.replaceRange(s, 3, 3 + s.length());
}
}
class B4L implements ActionListener {
public void actionPerformed(ActionEvent e) {
t2.insert(" Inserted ", 10);
}
}
public static void main(String[] args) {
TextAreaNew applet = new TextAreaNew();
Frame aFrame = new Frame("TextAreaNew");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(300,725);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
我们发现只能在构造TextArea时可以掌握转动条.一样,即便TE AR没有转动条,我们转动光标也将被禁止（可通过运行这个例子中考证这种行为）.
3. 复选框和单选钮
正如早先指出的那样,复选框和单选钮都是同一个类成立的.单选钮和复选框略有差别,它是复选框安设到CheckboxGroup中构成的.在此中任一种情形下,风趣的ItemEvent事件为我们成立一个ItemListener项目接纳器.
当处理一组复选框大概单选钮时,我们有一个不错的挑选.我们可以成立一个新的内部类去为每个复选框处理事件,大概成立一个内部类判断哪个复选框被单击并注册一个内部类单独的对象为每个复选对象.下面的例子演示了两种办法:
//: RadioCheckNew.java
// Radio buttons and Check Boxes in Java 1.1
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class RadioCheckNew extends Applet {
TextField t = new TextField(30);
Checkbox[] cb = {
new Checkbox("Check Box 1"),
new Checkbox("Check Box 2"),
new Checkbox("Check Box 3") };
CheckboxGroup g = new CheckboxGroup();
Checkbox
cb4 = new Checkbox("four", g, false),
cb5 = new Checkbox("five", g, true),
cb6 = new Checkbox("six", g, false);
public void init() {
t.setEditable(false);
add(t);
ILCheck il = new ILCheck();
for(int i = 0; i < cb.length; i++) {
cb[i].addItemListener(il);
add(cb[i]);
}
cb4.addItemListener(new IL4());
cb5.addItemListener(new IL5());
cb6.addItemListener(new IL6());
add(cb4); add(cb5); add(cb6);
}
// Checking the source:
class ILCheck implements ItemListener {
public void itemStateChanged(ItemEvent e) {
for(int i = 0; i < cb.length; i++) {
if(e.getSource().equals(cb[i])) {
t.setText("Check box " + (i + 1));
return;
}
}
}
}
// vs. an individual class for each item:
class IL4 implements ItemListener {
public void itemStateChanged(ItemEvent e) {
t.setText("Radio button four");
}
}
class IL5 implements ItemListener {
public void itemStateChanged(ItemEvent e) {
t.setText("Radio button five");
}
}
class IL6 implements ItemListener {
public void itemStateChanged(ItemEvent e) {
t.setText("Radio button six");
}
}
public static void main(String[] args) {
RadioCheckNew applet = new RadioCheckNew();
Frame aFrame = new Frame("RadioCheckNew");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(300,200);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
ILCheck拥有当我们增添大概削减复选框时自动调整的长处.当然,我们对单选钮利用这种办法也一样的好.但是,它仅当我们的逻辑足以广泛的支持这种办法时才会被利用.假如声明一个肯定的信号——我们将反复操纵独立的接纳器类,不然我们将完毕一串条件语句.
4. 下拉列表
下拉列表在Java 1.1版中当一个挑选被改变时一样利用ItemListener去奉告我们:
//: ChoiceNew.java
// Drop-down lists with Java 1.1
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class ChoiceNew extends Applet {
String[] description = { "Ebullient", "Obtuse",
"Recalcitrant", "Brilliant", "Somnescent",
"Timorous", "Florid", "Putrescent" };
TextField t = new TextField(100);
Choice c = new Choice();
Button b = new Button("Add items");
int count = 0;
public void init() {
t.setEditable(false);
for(int i = 0; i < 4; i++)
c.addItem(description[count++]);
add(t);
add(c);
add(b);
c.addItemListener(new CL());
b.addActionListener(new BL());
}
class CL implements ItemListener {
public void itemStateChanged(ItemEvent e) {
t.setText("index: " + c.getSelectedIndex()
+ " " + e.toString());
}
}
class BL implements ActionListener {
public void actionPerformed(ActionEvent e) {
if(count < description.length)
c.addItem(description[count++]);
}
}
public static void main(String[] args) {
ChoiceNew applet = new ChoiceNew();
Frame aFrame = new Frame("ChoiceNew");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(750,100);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
这个程序中没什么分外新颖的东西（除了Java 1.1版的UI类里少数几个值得关注的缺陷）.
5. 列表
我们消除了Java 1.0中List计划的一个缺陷,就是List不能像我们但愿的那样工作:它会与单击在一个列表元素上发生冲突.
//: ListNew.java
// Java 1.1 Lists are easier to use
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class ListNew extends Applet {
String[] flavors = { "Chocolate", "Strawberry",
"Vanilla Fudge Swirl", "Mint Chip",
"Mocha Almond Fudge", "Rum Raisin",
"Praline Cream", "Mud Pie" };
// Show 6 items, allow multiple selection:
List lst = new List(6, true);
TextArea t = new TextArea(flavors.length, 30);
Button b = new Button("test");
int count = 0;
public void init() {
t.setEditable(false);
for(int i = 0; i < 4; i++)
lst.addItem(flavors[count++]);
add(t);
add(lst);
add(b);
lst.addItemListener(new LL());
b.addActionListener(new BL());
}
class LL implements ItemListener {
public void itemStateChanged(ItemEvent e) {
t.setText("");
String[] items = lst.getSelectedItems();
for(int i = 0; i < items.length; i++)
t.append(items[i] + "\n");
}
}
class BL implements ActionListener {
public void actionPerformed(ActionEvent e) {
if(count < flavors.length)
lst.addItem(flavors[count++], 0);
}
}
public static void main(String[] args) {
ListNew applet = new ListNew();
Frame aFrame = new Frame("ListNew");
aFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
aFrame.add(applet, BorderLayout.CENTER);
aFrame.setSize(300,200);
applet.init();
applet.start();
aFrame.setVisible(true);
}
} ///:~
我们可以注意到在列表项中无需分外的逻辑需求去支持一个单击行动.我们正仿佛我们在别的地方所做的那样附加上一个接纳器.
6. 菜单
为菜单处理事件看起来受益于Java 1.1版的事件模子,但Java生成菜单的办法常常麻烦并且需求一些手工编写代码.生成菜单的精确办法看起来像资源而不是一些代码.请牢紧记着编程工具会遍及地为我们处理成立的菜单,因此这可以削减我们的痛楚（只要它们会一样处理保护任务!）.别的,我们将发现菜单不支持并且将招致混乱的事件:菜单项利用ActionListeners（行动接纳器）,但复选框菜单项利用ItemListeners（项目接纳器）.菜单对象一样能支持ActionListeners（行动接纳器）,但普通不那么有效.普通来说,我们会附加接纳器到每个菜单项或复选框菜单项,但下面的例子（对先前例子的改正）演示了一个结合捕捉多个菜单组件到一个单独的接纳器类的办法.正像我们将看到的,它大概不值得为这而激烈地争辩.
//: MenuNew.java
// Menus in Java 1.1
import java.awt.*;
import java.awt.event.*;
public class MenuNew extends Frame {
String[] flavors = { "Chocolate", "Strawberry",
"Vanilla Fudge Swirl", "Mint Chip",
"Mocha Almond Fudge", "Rum Raisin",
"Praline Cream", "Mud Pie" };
TextField t = new TextField("No flavor", 30);
MenuBar mb1 = new MenuBar();
Menu f = new Menu("File");
Menu m = new Menu("Flavors");
Menu s = new Menu("Safety");
// Alternative approach:
CheckboxMenuItem[] safety = {
new CheckboxMenuItem("Guard"),
new CheckboxMenuItem("Hide")
};
MenuItem[] file = {
// No menu shortcut:
new MenuItem("Open"),
// Adding a menu shortcut is very simple:
new MenuItem("Exit",
new MenuShortcut(KeyEvent.VK_E))
};
// A second menu bar to swap to:
MenuBar mb2 = new MenuBar();
Menu fooBar = new Menu("fooBar");
MenuItem[] other = {
new MenuItem("Foo"),
new MenuItem("Bar"),
new MenuItem("Baz"),
};
// Initialization code:
{
ML ml = new ML();
CMIL cmil = new CMIL();
safety[0].setActionCommand("Guard");
safety[0].addItemListener(cmil);
safety[1].setActionCommand("Hide");
safety[1].addItemListener(cmil);
file[0].setActionCommand("Open");
file[0].addActionListener(ml);
file[1].setActionCommand("Exit");
file[1].addActionListener(ml);
other[0].addActionListener(new FooL());
other[1].addActionListener(new BarL());
other[2].addActionListener(new BazL());
}
Button b = new Button("Swap Menus");
public MenuNew() {
FL fl = new FL();
for(int i = 0; i < flavors.length; i++) {
MenuItem mi = new MenuItem(flavors[i]);
mi.addActionListener(fl);
m.add(mi);
// Add separators at intervals:
if((i+1) % 3 == 0)
m.addSeparator();
}
for(int i = 0; i < safety.length; i++)
s.add(safety[i]);
f.add(s);
for(int i = 0; i < file.length; i++)
f.add(file[i]);
mb1.add(f);
mb1.add(m);
setMenuBar(mb1);
t.setEditable(false);
add(t, BorderLayout.CENTER);
// Set up the system for swapping menus:
b.addActionListener(new BL());
add(b, BorderLayout.NORTH);
for(int i = 0; i < other.length; i++)
fooBar.add(other[i]);
mb2.add(fooBar);
}
class BL implements ActionListener {
public void actionPerformed(ActionEvent e) {
MenuBar m = getMenuBar();
if(m == mb1) setMenuBar(mb2);
else if (m == mb2) setMenuBar(mb1);
}
}
class ML implements ActionListener {
public void actionPerformed(ActionEvent e) {
MenuItem target = (MenuItem)e.getSource();
String actionCommand =
target.getActionCommand();
if(actionCommand.equals("Open")) {
String s = t.getText();
boolean chosen = false;
for(int i = 0; i < flavors.length; i++)
if(s.equals(flavors[i])) chosen = true;
if(!chosen)
t.setText("Choose a flavor first!");
else
t.setText("Opening "+ s +". Mmm, mm!");
} else if(actionCommand.equals("Exit")) {
dispatchEvent(
new WindowEvent(MenuNew.this,
WindowEvent.WINDOW_CLOSING));
}
}
}
class FL implements ActionListener {
public void actionPerformed(ActionEvent e) {
MenuItem target = (MenuItem)e.getSource();
t.setText(target.getLabel());
}
}
// Alternatively, you can create a different
// class for each different MenuItem. Then you
// Don't have to figure out which one it is:
class FooL implements ActionListener {
public void actionPerformed(ActionEvent e) {
t.setText("Foo selected");
}
}
class BarL implements ActionListener {
public void actionPerformed(ActionEvent e) {
t.setText("Bar selected");
}
}
class BazL implements ActionListener {
public void actionPerformed(ActionEvent e) {
t.setText("Baz selected");
}
}
class CMIL implements ItemListener {
public void itemStateChanged(ItemEvent e) {
CheckboxMenuItem target =
(CheckboxMenuItem)e.getSource();
String actionCommand =
target.getActionCommand();
if(actionCommand.equals("Guard"))
t.setText("Guard the Ice Cream! " +
"Guarding is " + target.getState());
else if(actionCommand.equals("Hide"))
t.setText("Hide the Ice Cream! " +
"Is it cold? " + target.getState());
}
}
public static void main(String[] args) {
MenuNew f = new MenuNew();
f.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.setSize(300,200);
f.setVisible(true);
}
} ///:~
在我们开始初始化节（由注解“Initialization code:”后的右大括号指明）的前脸部份的代码同先前（Java 1.0版）版本相同.这里我们可以注意到项目接纳器和行动接纳器被附加在差别的菜单组件上.
Java 1.1支持“菜单快速键”,因此我们可以挑选一个菜单项目操纵键盘替换鼠标.这非常的简单;我们只要利用过载菜单项构建器设置第二个自变量为一个MenuShortcut（菜单快速键事件）对象便可.菜单快速键构建器设置重要的办法,当它按下时难以想象地显示在菜单项上.上面的例子增添了Control-E到“Exit”
菜单项中.
我们一样会注意setActionCommand()的利用.这看似一点陌生因为在各种情形下“action command”完好同菜单组件上的标签一样.为什么不恰好利用标签替换可挑选的字符串呢?这个难题是国际化的.假如我们重新用别的语言写这个程序,我们只需求改变菜单中的标签,并不检查代码中大概包含新错误的全部逻辑.因此使这对查抄文字字符串通合菜单组件的代码而言变得简单简单,当菜单标签能改变时“行动指令”可以不作任何的改变.全部这些代码同“行动指令”一同工作,因此它不会受改变菜单标签的影响.注意在这个程序中,不是全部的菜单组件都被它们的行动指令所检查,因此这些组件都没有它们的行动指令集.
大大都的构建器同前面的一样,将几个调用的非常增添到接纳器中.大量的工作发生在接纳器里.在前面例子的BL中,菜单交替发生.在ML中,“探求ring”办法被作为行动事件（ActionEvent）的资源并对它举行造型送入菜单项,然后得到行动指令字符串,再通过它去贯串串通组,当然条件是对它举行声明.这些大大都同前面的一样,但请注意假如“Exit”被选中,通过进入封装类对象的句柄（MenuNew.this）并成立一个WINDOW_CLOSING事件,一个新的窗口事件就被成立了.新的事件被分配到封装类对象的dispatchEvent()办法,然后完毕调用windowsClosing()内部帧的窗口接纳器（这个接纳器作为一个内部类被成立在main()里）,仿佛这是“正常”产生消息的办法.通过这种机制,我们可以在任何情形下疾速处理任何的信息,因此,它非常的强盛.
FL接纳器是很简单固然它能处理特别菜单的全部差别的特点.假如我们的逻辑非常的简单明了,这种办法对我们就很有效处,但普通,我们利用这种办法时需求与FooL,BarL和BazL一道利用,它们每个都附加到一个单独的菜单组件上,因此必定无需测试逻辑,并且使我们精确地辨识出谁调用了接纳器.这种办法产生了大量的类,内部代码趋向于变得玲珑和处理起来简单、安全.
7. 对话框
在这个例子里直接重写了早期的ToeTest.java程序.在这个新的版本里,任何事件都被安设进一个内部类中.固然这完好消除了需求记录产生的任何类的麻烦,作为ToeTest.java的一个例子,它能使内部类的概念变得不那迢遥.在这点,内嵌类被嵌套达四层之深!我们需求的这种计划决意了内部类的长处能否值得增添越发复杂的事物.别的,当我们成立一个非静态的内部类时,我们将捆绑非静态类到它四周的类上.有时,单独的类可以更简单地被复用.
//: ToeTestNew.java
// Demonstration of dialog boxes
// and creating your own components
import java.awt.*;
import java.awt.event.*;
public class ToeTestNew extends Frame {
TextField rows = new TextField("3");
TextField cols = new TextField("3");
public ToeTestNew() {
setTitle("Toe Test");
Panel p = new Panel();
p.setLayout(new GridLayout(2,2));
p.add(new Label("Rows", Label.CENTER));
p.add(rows);
p.add(new Label("Columns", Label.CENTER));
p.add(cols);
add(p, BorderLayout.NORTH);
Button b = new Button("go");
b.addActionListener(new BL());
add(b, BorderLayout.SOUTH);
}
static final int BLANK = 0;
static final int XX = 1;
static final int OO = 2;
class ToeDialog extends Dialog {
// w = number of cells wide
// h = number of cells high
int turn = XX; // Start with x's turn
public ToeDialog(int w, int h) {
super(ToeTestNew.this,
"The game itself", false);
setLayout(new GridLayout(w, h));
for(int i = 0; i < w * h; i++)
add(new ToeButton());
setSize(w * 50, h * 50);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
dispose();
}
});
}
class ToeButton extends Canvas {
int state = BLANK;
ToeButton() {
addMouseListener(new ML());
}
public void paint(Graphics g) {
int x1 = 0;
int y1 = 0;
int x2 = getSize().width - 1;
int y2 = getSize().height - 1;
g.drawRect(x1, y1, x2, y2);
x1 = x2/4;
y1 = y2/4;
int wide = x2/2;
int high = y2/2;
if(state == XX) {
g.drawLine(x1, y1,
x1 + wide, y1 + high);
g.drawLine(x1, y1 + high,
x1 + wide, y1);
}
if(state == OO) {
g.drawOval(x1, y1,
x1 + wide/2, y1 + high/2);
}
}
class ML extends MouseAdapter {
public void mousePressed(MouseEvent e) {
if(state == BLANK) {
state = turn;
turn = (turn == XX ? OO : XX);
}
else
state = (state == XX ? OO : XX);
repaint();
}
}
}
}
class BL implements ActionListener {
public void actionPerformed(ActionEvent e) {
Dialog d = new ToeDialog(
Integer.parseInt(rows.getText()),
Integer.parseInt(cols.getText()));
d.show();
}
}
public static void main(String[] args) {
Frame f = new ToeTestNew();
f.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.setSize(200,100);
f.setVisible(true);
}
} ///:~
由于“静态”的东西只能位于类的外部一级,所以内部类不大概拥有静态数据大概静态内部类.
8. 文件对话框
这个例子是直接用新事件模子对FileDialogTest.java改正而来.
//: FileDialogNew.java
// Demonstration of File dialog boxes
import java.awt.*;
import java.awt.event.*;
public class FileDialogNew extends Frame {
TextField filename = new TextField();
TextField directory = new TextField();
Button open = new Button("Open");
Button save = new Button("Save");
public FileDialogNew() {
setTitle("File Dialog Test");
Panel p = new Panel();
p.setLayout(new FlowLayout());
open.addActionListener(new OpenL());
p.add(open);
save.addActionListener(new SaveL());
p.add(save);
add(p, BorderLayout.SOUTH);
directory.setEditable(false);
filename.setEditable(false);
p = new Panel();
p.setLayout(new GridLayout(2,1));
p.add(filename);
p.add(directory);
add(p, BorderLayout.NORTH);
}
class OpenL implements ActionListener {
public void actionPerformed(ActionEvent e) {
// Two arguments, defaults to open file:
FileDialog d = new FileDialog(
FileDialogNew.this,
"What file do you want to open?");
d.setFile("*.java");
d.setDirectory("."); // Current directory
d.show();
String yourFile = "*.*";
if((yourFile = d.getFile()) != null) {
filename.setText(yourFile);
directory.setText(d.getDirectory());
} else {
filename.setText("You pressed cancel");
directory.setText("");
}
}
}
class SaveL implements ActionListener {
public void actionPerformed(ActionEvent e) {
FileDialog d = new FileDialog(
FileDialogNew.this,
"What file do you want to save?",
FileDialog.SAVE);
d.setFile("*.java");
d.setDirectory(".");
d.show();
String saveFile;
if((saveFile = d.getFile()) != null) {
filename.setText(saveFile);
directory.setText(d.getDirectory());
} else {
filename.setText("You pressed cancel");
directory.setText("");
}
}
}
public static void main(String[] args) {
Frame f = new FileDialogNew();
f.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.setSize(250,110);
f.setVisible(true);
}
} ///:~
假如全部的改变是这样的简单那将有多棒,但至少它们已充足简单,并且我们的代码已受益于这改良的可读性上.以上是“再探早期示例[Java编程]”的内容，如果你对以上该文章内容感兴趣，你可以看看七道奇为您推荐以下文章：
| 本文地址： | 与您的QQ/BBS好友分享! |
- 好的评价 如果您觉得此文章好，就请您
0%(0) 
- 差的评价 如果您觉得此文章差，就请您
0%(0) 
- ·上一篇文章：动态绑定事件(java AWT)
- ·下一篇文章：用Java 1.1 AWT制作窗口和程序片
- ·
中查找“再探早期示例”更多相关内容 - ·
中查找“再探早期示例”更多相关内容
评论内容只代表网友观点，与本站立场无关！
评论摘要(共 0 条，得分 0 分，平均 0 分)
查看完整评论