Java中利用JFrame创建窗体

1. 一个简单例子：

1. public class Test(){
2. public static void main(String[] args){
3. JFrame frame = new JFrame();
4. JPanel panel = new JPanel();
5. JTextArea textArea = new JTextArea();
6. panel.setLayout(new GridLayout());
7. textArea.setText("test");
8. //当TextArea里的内容过长时生成滚动条
9. panel.add(new JScrollPane(textArea));
10. frame.add(panel);
11. ,200);
12. frame.setVisible(true);
13. }
14. }

2.创建窗体

在开发Java应用程序时，通常情况下利用JFrame创建窗口。利用JFrame创建的窗口分别包含一个标题、最小化按钮、最大化按钮和关闭按钮

在利用JFrame创建窗口时，需要设置单击关闭按钮时执行的动作 ，设置方法为通过JFrame对象的setDefault CloseOperation（int operation）方法，该方法的入口参数可以从JFrame类的静态常量中选择，可选的静态常量如表1所示。



表1 JFrame类中用来设置关闭按钮动作的静态常量

设置单击关闭按钮时执行动作的典型代码如下：

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) ：

JFrame窗口的默认显示位置为从（0,0）点开始绘制，即从显示器的左上角开始绘制。通常情况下更希望显示在显示器的中央，可以通过Toolkit类 的静态方法getDefaultToolkit()获得一个Toolkit类的对象，然后通过Toolkit对象的getScreenSize()方法获 得一个Dimension类的对象，通过Dimension对象可以得到显示器的大小，例如显示器的宽度和高度，获得Dimension对象的典型代码如 下：

Dimension displaySize = Toolkit.getDefaultToolkit().getScreenSize();

通过JFrame对象的getSize()方法也可以得到一个Dimension类的对象，通过Dimension对象可以得到JFrame窗口的大小，例如JFrame窗口的宽度和高度，获得Dimension对象的典型代码如下：

Dimension frameSize = frame.getSize();

利用上面得到的两个Dimension类的对象，就可以计算出显示在显示器中央时的起始绘制点了，然后通过JFrame对象的setLocation（int x, int y）方法，设置JFrame窗口在显示器中的起始绘制点，典型代码如下：

frame.setLocation((displaySize.width - frameSize.width) / 2,(displaySize.height - frameSize.height) / 2);

利用JFrame创建的窗口默认是不可见的，即在运行时不在显示器上绘制窗口，设置为可见的方法是通过JFrame对象的setVisible（boolean b）方法，并将入口参数设为true，典型代码如下：

frame.setVisible(true): 

下面将通过一个例子，实现利用JFrame创建一个图1所示的窗口。

下面的代码将创建一个标题为“利用JFrame创建窗口”的窗口，该窗口的关闭按钮执行的动作是退出窗口，该窗口将显示在显示器的中央，代码如下：

1. public static void main(String[] args) {
2. JFrame frame = new JFrame("利用JFrame创建窗口"); // 创建指定标题的JFrame窗口对象
3. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 关闭按钮的动作为退出窗口
4. , 300);                          // 设置窗口大小
5. Dimension displaySize = Toolkit.getDefaultToolkit().getScreenSize(); // 获得显示器大小对象
6. Dimension frameSize = frame.getSize();             // 获得窗口大小对象
7. if (frameSize.width > displaySize.width)
8. frameSize.width = displaySize.width;           // 窗口的宽度不能大于显示器的宽度
9. if (frameSize.height > displaySize.height)
10. frameSize.height = displaySize.height;          // 窗口的高度不能大于显示器的高度
11. ,
12. ); // 设置窗口居中显示器显示
13. frame.setVisible(true);                          // 设置窗口为可见的，默认为不可见
14. }

3.修改图标：

      setIconImage (Toolkit . getDefaultToolkit (). createImage (

                    getClass (). getResource ("login.png" )));

    （注意：图片login.png要放在与调用该图片的类于同一个文件夹；另，Java好像不支持ico格式）

4.Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 

在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。

问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现这个效果，就是执行以下语句

textArea.paintImmediately(textArea.getBounds());

或

  textArea.paintImmediately(textArea.getX(), textArea.getY(), textArea.getWidth(), textArea.getHeight());

这时，你会发现你刚才增加的消息已经被实时地显示出来了。

5. 画图并添加鼠标事件

1. final Image img = Toolkit.getDefaultToolkit().getImage(
2. Test.class.getResource("map.png"));
3. JTextArea ta = new JTextArea() {
4. {
5. setOpaque(false);// 设置不透明的参数，缺少时背景图片不显示
6. }
7. public void paint(Graphics g) {
8. , 0, this);
9. super.paint(g);
10. }
11. };
12. MouseListener ml = new MouseListener() {
13. public void mouseClicked(MouseEvent e) {
14. ) {
15. System.out.println("Mouse double clicked");
16. }
17. }
18. public void mouseEntered(MouseEvent e) {
19. // TODO Auto-generated method stub
20. }
21. public void mouseExited(MouseEvent e) {
22. // TODO Auto-generated method stub
23. }
24. public void mousePressed(MouseEvent e) {
25. // TODO Auto-generated method stub
26. }
27. public void mouseReleased(MouseEvent e) {
28. // TODO Auto-generated method stub
29. }
30. };
31. ta.addMouseListener(ml);
32. , 0, 300, 200);
33. ta.setEditable(false);

6.另一个例子：在一个TextArea里写内容，其他两个同时显示

1. /*JTextArea是多行文本编辑器，JTextField是一个简单的单行文本编辑器，它们都由JTextComponent类派生，所以它们包含一些共同的方法，如设置和获取所显示的文本，指定文本是否可编辑，或者是否只读，管理文本内的光标位置以及管理文本选择等。
2. 文本组件的模型是一个称为Document的对象，对于一个JTextArea或JTextField，要为之增加或删除文本，就会改变相应的Document。当出现某种改动时，要由文档本身（而不是可视的组件）来生成与文本相关的事件。因此，为了接收JTextArea修改的通知，就要向底层Document注册，而不是向JTextArea组件本身注册：
3. */
4. JTextArea textArea = new JTextArea();
5. Document d = textArea.getDocument();
6. d.addDocumentListener(someListener);
7. /*
8. 一个例子如下，在任意的一个文本区中键入的内容，在三个区中都将得以体现。我们要做的就是让所有的文本区都共享一个数据模型。
9. */
10. import java.awt.Container;
11. import java.awt.GridLayout;
12. import javax.swing.JFrame;
13. import javax.swing.JScrollPane;
14. import javax.swing.JTextArea;
15. public class ShareModel {
16. public static void main(String[] args) {
17. JFrame frame = new JFrame("ShareModel");
18. JTextArea areaFiftyOne = new JTextArea();
19. JTextArea areaFiftyTwo = new JTextArea();
20. areaFiftyTwo.setDocument(areaFiftyOne.getDocument());
21. JTextArea areaFiftyThree = new JTextArea();
22. areaFiftyThree.setDocument(areaFiftyOne.getDocument());
23. Container content = frame.getContentPane();
24. ,1));
25. content.add(new JScrollPane(areaFiftyOne));
26. content.add(new JScrollPane(areaFiftyTwo));
27. content.add(new JScrollPane(areaFiftyThree));
28. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
29. ,300);
30. frame.setVisible(true);
31. }
32. }
33. /*
34. 在一个文本区中键入时，此文本区将接受键盘事件，它会调用文档中的方法来更新数据，相应的，文档会向其它文本区发送事件，通知出现了更新，从而使它们能够正确的显示文档的新数据。不过，所有这一切都无需我们关心。要做的只是通知文本区使用同一数据。Swing会接管其余的一切。
35. 另外需要注意的，JTextArea没有滚动功能，超出文本区域的内容无法显示出来，通过鼠标拖动也无法看到。但它实现了Swing Scrollable接口。必须把它放置在JScrollPane的内部才能实现滚动。
36. */

7.Java 关闭窗体的六种方法 



--------------------------------------------------------------------------------

1. //1.使用JFrame的enableEvents和processWindowEvent
2. //Frame1.java
3. import java.awt.*;
4. import java.awt.event.*;
5. import javax.swing.*;
6. public class Frame1 extends JFrame {
7. public Frame1() {
8. enableEvents(AWTEvent.WINDOW_EVENT_MASK);
9. , 300));
10. this.setTitle("Frame1");
11. }
12. protected void processWindowEvent(WindowEvent e) {
13. super.processWindowEvent(e);
14. if (e.getID() == WindowEvent.WINDOW_CLOSING) {
15. );
16. }
17. }
18. }
19. //2.直接实现WindowListener接口
20. //Frame1.java
21. import java.awt.*;
22. import java.awt.event.*;
23. public class Frame1 extends Frame implements WindowListener {
24. public Frame1() {
25. , 300));
26. this.setTitle("Frame1");
27. this.addWindowListener(this);
28. }
29. public void windowClosing(WindowEvent windowEvent) {
30. );
31. }
32. public void windowOpened(WindowEvent windowEvent) { }
33. public void windowClosed(WindowEvent windowEvent) { }
34. public void windowIconified(WindowEvent windowEvent) { }
35. public void windowDeiconified(WindowEvent windowEvent) { }
36. public void windowActivated(WindowEvent windowEvent) { }
37. public void windowDeactivated(WindowEvent windowEvent) { }
38. }
39. //3.直接继承窗体适配器WindowAdapter
40. //Frame1.java
41. import java.awt.*;
42. import java.awt.event.*;
43. public class Frame1 extends WindowAdapter {
44. public Frame1() {
45. Frame f=new Frame();
46. , 300));
47. f.setTitle("Frame1");
48. f.addWindowListener(this);
49. f.setVisible(true);
50. }
51. public static void main(String[] s){
52. new Frame1();
53. }
54. public void windowClosing(WindowEvent windowEvent) {
55. );
56. }
57. }
58. //4.间接继承窗体适配器WindowAdapter
59. //Frame1.java
60. import java.awt.*;
61. import java.awt.event.*;
62. public class Frame1 extends Frame {
63. public Frame1() {
64. , 300));
65. this.setTitle("Frame1");
66. this.addWindowListener(new winAdapter());
67. this.setVisible(true);
68. }
69. public static void main(String[] s){
70. new Frame1();
71. }
72. }
73. class winAdapter extends WindowAdapter{
74. public void windowClosing(WindowEvent windowEvent) {
75. );
76. }
77. }
78. //5.间接实现WindowListener接口
79. //Frame1.java
80. import java.awt.*;
81. import java.awt.event.*;
82. public class Frame1 extends Frame {
83. public Frame1() {
84. , 300));
85. this.setTitle("Frame1");
86. this.addWindowListener(new winEventHandle());
87. this.setVisible(true);
88. }
89. public static void main(String[] s){
90. new Frame1();
91. }
92. }
93. class winEventHandle implements WindowListener {
94. public void windowClosing(WindowEvent windowEvent) {
95. );
96. }
97. public void windowOpened(WindowEvent windowEvent) { }
98. public void windowClosed(WindowEvent windowEvent) { }
99. public void windowIconified(WindowEvent windowEvent) { }
100. public void windowDeiconified(WindowEvent windowEvent) { }
101. public void windowActivated(WindowEvent windowEvent) { }
102. public void windowDeactivated(WindowEvent windowEvent) { }
103. }
104. //6.使用Inner Class
105. //Frame1.java
106. import java.awt.*;
107. import java.awt.event.*;
108. public class Frame1{
109. public Frame1(){
110. Frame f=new Frame();
111. f.addWindowListener(new WindowAdapter(){
112. public void windowClosing(WindowEvent e){
113. );
114. }
115. });
116. , 300));
117. f.setVisible(true);
118. }
119. public static void main(String[] s){
120. new Frame1();
121. }
122. }