java Swing基础教程之图形化实例代码

时间:2022-06-07 17:10:34

java  Swing基础教程之图形化实例代码

与多线程、泛型等不同,Swing主要在于使用。

下面主要放代码和注释,少说话。

(一)基本框架

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package Swing;
 
import java.awt.*;
import javax.swing.*;
 
/**
 *
 * @author QuinnNorris
 * 基本框架
 */
public class FrameTest {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
 
    // 开启一个线程,所有的Swing组件必须由事件分派线程进行配置,线程将鼠标点击和按键控制转移到用户接口组件。
    EventQueue.invokeLater(new Runnable() {
      // 匿名内部类,是一个Runnable接口的实例,实现了run方法
      public void run() {
 
        SimpleFrame frame = new SimpleFrame();
        // 创建下面自己定义的SimpleFrame类对象,以便于调用构造器方法
 
        frame.setExtendedState(Frame.MAXIMIZED_BOTH);
        // 将窗口最大化
        // 其他可选属性:Frame.NORMAL ICONIFIED MAXIMIZED_HORIZ MAXIMIZED_VERT
        // MAXIMIZED_BOTH
 
        frame.setTitle("Christmas");
        // 设置窗口标题
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 选择当用户关闭框架时进行的操作 ,在有些时候需要将窗口隐藏,不能直接退出需要用到这个方法
 
        frame.setVisible(true);
        // 将窗口可见化,这样以便用户在第一次看见窗口之前我们能够向其中添加内容
      }
 
    });
  }
  // main结束时,程序并没有结束,而是结束了主线程,知道所有框架关闭或者调用了 System.exit事才终止程序
}
 
class SimpleFrame extends JFrame {
  public SimpleFrame() {
 
    Toolkit kit = Toolkit.getDefaultToolkit();
    // 修改窗口在屏幕上面的位置,改变窗口大小
    // Toolkit类包含很多与本地窗口交互的方法
 
    Dimension screenSize = kit.getScreenSize();
    // Toolkit的获取频幕大小的方法返回一个Dimension的类对象
 
    setSize((int) (screenSize.getWidth()), (int) (screenSize.getHeight()));
    // setBounds(0,0,(int)(screenSize.getWidth()),(int)(screenSize.getHeight()));
    // 定义窗口的位置和大小
    // setLocation(0,0); 定位窗口距离左上角的位置
    // setLocationByPlatform(true); 让窗口系统控制窗口位置,距离上一个窗口很小的偏移量
 
    // 用图片来替换窗口图标
    Image img = new ImageIcon("D:/icon.png").getImage();
    setIconImage(img);
 
  }
}

输出结果:一个充满整个屏幕的框体,标题栏名字叫做Christmas,图表是自己填充的图片。

(二)输出文字

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package Swing;
 
import java.awt.*;
import javax.swing.*;
 
/**
 *
 * @author QuinnNorris
 * 输出文字
 */
public class HelloWorld {
 
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
 
    // 开启一个线程,所有的Swing组件必须由事件分派线程进行配置,线程将鼠标点击和按键控制转移到用户接口组件
    EventQueue.invokeLater(new Runnable() {
      // 匿名内部类,是一个Runnable接口的实例,实现了run方法
      public void run() {
 
        JFrame frame = new HelloWorldFrame();
        // HelloworldFrame在下面定义,继承了JFrame,使用其中的构造器方法
 
        frame.setTitle("HelloWrold");
        // 设置标题
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 选择当用户关闭框架时进行的操作 ,在有些时候需要将窗口隐藏,不能直接退出需要用到这个方法
 
        frame.setVisible(true);
        // 将窗口可见化,这样以便用户在第一次看见窗口之前我们能够向其中添加内容
      }
    });
 
  }
 
}
 
// 编写继承了JFrame的类,我们的工作在这里进行
class HelloWorldFrame extends JFrame {
  public HelloWorldFrame() {
 
    add(new HelloWorldComponent());
    //向其中添加一个实例化的实现JComponent类的子类
 
    pack();
    //调用框架组件的首选大小,或者我们可以用SetSize方法来替换它
  }
}
 
class HelloWorldComponent extends JComponent {
  public static final int MESSAGE_X = 75;
  public static final int MESSAGE_Y = 100;
 
  private static final int DEFAULT_WIDTH = 300;
  private static final int DEFAULT_HEIGHT = 200;
 
  /**
   * 我们覆盖了这个以用来书写内容
   *
   * @param g
   *      Graphics对象保存着用于绘制图像和文本的设置
   */
  public void paintComponent(Graphics g) {
    g.drawString("Hello World!", MESSAGE_X, MESSAGE_Y);
    // 参数:书写内容,字符串中第一个字符位于从左向右75像素,字符串中第一个字符从上向下100像素
  }
 
  /**
   * 我们覆盖了这个方法来表示出这个类的组件的大小
   *
   * @return 返回这个类的组件本身应该有多大
   */
  public Dimension getPreferredSize() {
    return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    // 返回一个Dimension对象,表示这个组件的大小
  }
}

输出结果:位于左上角的名字叫做HelloWrold的小窗口,在窗口中部有“Hello World!”字样。

(三)打印图形

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package Swing;
 
import java.awt.EventQueue;
 
import javax.swing.*;
 
import java.awt.*;
import java.awt.geom.*;
 
/**
 *
 * @author QuinnNorris
 * 打印图形
 */
public class DrawTest {
 
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
 
    // 开启一个线程,所有的Swing组件必须由事件分派线程进行配置,线程将鼠标点击和按键控制转移到用户接口组件。
    EventQueue.invokeLater(new Runnable()
    {
      // 匿名内部类,是一个Runnable接口的实例,实现了run方法
      public void run(){
 
        JFrame frame = new DrawFrame();
        // 创建下面自己定义的SimpleFrame类对象,以便于调用构造器方法
 
        frame.setTitle("DrawTest");
        // 设置标题
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 选择当用户关闭框架的时候进行的操作 ,在有些时候需要将窗口隐藏,不能直接退出需要用到这个方法
 
        frame.setVisible(true);
        // 将窗口可见化,这样以便用户在第一次看见窗口之前我们能够向其中添加内容
      }
    });
  }
 
}
 
 
class DrawFrame extends JFrame
{
  public DrawFrame(){
 
    add(new DrawComponent());
    //向其中添加一个实例化的实现JComponent类的子类
 
    pack();
    //调用框架组件的首选大小,或者我们可以用SetSize方法来替换它
  }
}
 
class DrawComponent extends JComponent
{
  private static final int DEFAULT_WIDTH = 400;
  private static final int DEFAULT_HEIGHT = 400;
 
  /**
   * 我们覆盖了这个以用来打印图形
   *
   * @param g
   *      Graphics对象是我们需要用的Graphics2D的父类
   */
  public void paintComponent(Graphics g){
 
    Graphics2D g2 = (Graphics2D)g;
    //实例化Graphics2D这个类的对象,他是参数Graphics2D的一个子类
 
    double leftX = 100;
    double topY = 100;
    double width = 200;
    double height = 150;
    //我们设置矩形的四个属性
 
    Rectangle2D rect = new Rectangle2D.Double(leftX,topY,width,height);
    //创建一个Rectangle2D的对象,这个对象继承了Sharp接口
    //Double是其中的一个静态内部类,当我们初始化时需要在Double中设置参数
 
    g2.draw(rect);
    //传入一个实现Sharp接口的实例,并在画布上画出
 
    Ellipse2D ellipse = new Ellipse2D.Double();
    //创建一个椭圆的实例
 
    ellipse.setFrame(rect);
    //椭圆和矩形类是兄弟关系,因为他们有着相同的边界判断方式
    //这里我们直接用rect来对椭圆形进行描述(通过椭圆的外接矩形)
 
    g2.draw(ellipse);
    //传入一个实现Sharp接口的实例,并在画布上画出
 
    g2.draw(new Line2D.Double(leftX,topY,leftX+width,topY+height));
    //在画布上画出一条直线
 
    double centerX = rect.getCenterX();
    double centerY = rect.getCenterY();
    double radius = 150;
    //定义圆心坐标和半径
 
    Ellipse2D circle = new Ellipse2D.Double();
    //创建一个圆的实例
    circle.setFrameFromCenter(centerX, centerY, centerX+radius, centerY+radius);
    //设置坐标和半径
    g2.draw(circle);
    //在画布上画出一个圆
  }
 
  /**
   * 我们覆盖了这个方法来表示出这个类的组件的大小
   *
   * @return 返回这个类的组件本身应该有多大
   */
  public Dimension getPreferredSize(){
    return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
    // 返回一个Dimension对象,表示这个组件的大小
  }
}

输出结果:左上角的窗口中有一个椭圆,外面有一个外界矩形,有一条从矩形左上角到右下角的直线,以这个矩形中心为原点有一个半径为150像素的圆。

(四)图形上色

?
1
2
3
4
5
6
7
8
9
10
11
12
Rectangle2D rect = new Rectangle2D.Double(leftX,topY,width,height);
//创建一个Rectangle2D的对象,这个对象继承了Sharp接口
//Double是其中的一个静态内部类,当我们初始化时需要在Double中设置参数
 
g2.setColor(Color.BLUE);
//为g2对象设置一种填充颜色,会影响线条颜色
 
g2.fill(rect);
//将我们选择的颜色填充到rect表示的封闭图形中
 
g2.draw(rect);
//传入一个实现Sharp接口的实例,并在画布上画出

在上一个代码其他部分不改变的情况下,插入这样两行代码(在1,4行代码的原位置中间插入2,3行代码)。得到上色效果。

输出结果:中间为蓝色矩形,以矩形中心为原点,150像素为半径有个蓝色线条的圆形。

(五)特殊字体

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package Swing;
 
import javax.swing.*;
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
 
/**
 *
 * @author QuinnNorris 特殊字体
 */
public class FontTest {
 
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
 
    // 开启一个线程,所有的Swing组件必须由事件分派线程进行配置,线程将鼠标点击和按键控制转移到用户接口组件。
    EventQueue.invokeLater(new Runnable() {
      // 匿名内部类,是一个Runnable接口的实例,实现了run方法
      public void run() {
        JFrame frame = new FontFrame();
        // 创建下面自己定义的SimpleFrame类对象,以便于调用构造器方法
 
        frame.setTitle("FontTest");
        // 设置标题
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 选择当用户关闭框架的时候进行的操作 ,在有些时候需要将窗口隐藏,不能直接退出需要用到这个方法
 
        frame.setVisible(true);
        // 将窗口可见化,这样以便用户在第一次看见窗口之前我们能够向其中添加内容
      }
    });
  }
 
}
 
class FontFrame extends JFrame {
  public FontFrame() {
    add(new FontComponent());
    // 向其中添加一个实例化的实现JComponent类的子类
 
    pack();
    // 调用框架组件的首选大小,或者我们可以用SetSize方法来替换它
  }
}
 
class FontComponent extends JComponent {
  private static final int DEFAULT_WIDTH = 300;
  private static final int DEFAULT_HEIGHT = 200;
 
  /**
   * 我们覆盖了这个以用来做一些工作
   *
   * @param g
   *      Graphics对象是我们需要用的Graphics2D的父类
   */
  public void paintComponent(Graphics g) {
    Graphics2D g2 = (Graphics2D) g;
    // 实例化Graphics2D这个类的对象,他是参数Graphics2D的一个子类
 
    String message = "Hello World!";
    // 写出我们要操作的文字
 
    Font f = new Font("Dialog", Font.BOLD, 36);
    // 创建一个字体类型,参数包括字体族,风格类型,大小
    // 也可以通过特殊的方法,调用加载得到本地的字体包
 
    g2.setFont(f);
    // 将f设置在g2之中
 
    FontRenderContext context = g2.getFontRenderContext();
    // 通过调用方法,得到屏幕设备字体属性的描述对象
 
    Rectangle2D bounds = f.getStringBounds(message, context);
    // getStringBounds方法返回一个包围着字符串的矩形
 
    double x = (DEFAULT_WIDTH - bounds.getWidth()) / 2;
    // bounds.getWidth方法可以获得字符串的宽度
 
    double y = (DEFAULT_HEIGHT - bounds.getHeight()) / 2;
    // bounds.getHeight方法可以获得字符串的高度
 
    double ascent = -bounds.getY();
    // 获得字体的上坡度
 
    double baseY = y + ascent;
    // 文字的基线位置
 
    g2.drawString(message, (int) x, (int) y);
    // 设置字符串位置
 
    g2.setPaint(Color.LIGHT_GRAY);
    // 设置线条颜色为亮灰色
 
    g2.draw(new Line2D.Double(x, baseY, x + bounds.getWidth(), baseY));
    // 在文字的基线上画下一条横线
 
    Rectangle2D rect = new Rectangle2D.Double(x, y, bounds.getWidth(),
        bounds.getHeight());
 
    g2.draw(rect);
  }
 
  /**
   * 我们覆盖了这个方法来表示出这个类的组件的大小
   *
   * @return 返回这个类的组件本身应该有多大
   */
  public Dimension getPreferredSize() {
    return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    // 返回一个Dimension对象,表示这个组件的大小
  }
}

输出结果:窗口正中间有文字“Hello World”,外围被一个灰色矩形包括,在基线的地方有一条横线分割。

(六)添加图片

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package Swing;
 
import javax.swing.*;
import java.awt.*;
 
/**
 *
 * @author QuinnNorris 添加图片
 */
public class ImageTest {
 
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
 
    // 开启一个线程,所有的Swing组件必须由事件分派线程进行配置,线程将鼠标点击和按键控制转移到用户接口组件。
    EventQueue.invokeLater(new Runnable() {
      // 匿名内部类,是一个Runnable接口的实例,实现了run方法
      public void run() {
        JFrame frame = new ImageFrame();
        // 创建下面自己定义的SimpleFrame类对象,以便于调用构造器方法
 
        frame.setTitle("ImageTest");
        // 设置标题
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 选择当用户关闭框架的时候进行的操作 ,在有些时候需要将窗口隐藏,不能直接退出需要用到这个方法
 
        frame.setVisible(true);
        // 将窗口可见化,这样以便用户在第一次看见窗口之前我们能够向其中添加内容
      }
    });
  }
 
}
 
class ImageFrame extends JFrame {
  public ImageFrame() {
    add(new ImageComponent());
    // 向其中添加一个实例化的实现JComponent类的子类
 
    pack();
    // 调用框架组件的首选大小,或者我们可以用SetSize方法来替换它
  }
}
 
class ImageComponent extends JComponent {
 
  private static final int DEFAULT_WIDTH = 300;
  private static final int DEFAULT_HEIGHT = 200;
 
  private Image image;
 
  /**
   * ImageComponent的构造函数,用来实例化图片
   */
  public ImageComponent(){
    image = new ImageIcon("D:/image.jpg").getImage();
    //通过路径得到图片
  }
 
  /**
   * 我们覆盖了这个以用来做一些工作
   *
   * @param g
   *     
   */
  public void paintComponent(Graphics g) {
    if(image == null ) return;
    //如果图片不正确,则直接返回避免发生错误
 
    g.drawImage(image, 0,0,null);
    //在画布上给出图片
  }
 
  /**
   * 我们覆盖了这个方法来表示出这个类的组件的大小
   *
   * @return 返回这个类的组件本身应该有多大
   */
  public Dimension getPreferredSize() {
    return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    // 返回一个Dimension对象,表示这个组件的大小
  }
}

输出结果:在画布以左上角为开始放置你添加的图片。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

原文链接:http://blog.csdn.net/quinnnorris/article/details/55667020