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);

}

}

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对象，表示这个组件的大小

}

}

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对象，表示这个组件的大小

}

}

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

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对象，表示这个组件的大小

}

}

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对象，表示这个组件的大小

}

}