• 第十九章绘图

    Java绘图类
    Graphics 类
           Grapics 类是所有图形上下文的抽象基类，它允许应用程序在组件以及闭屏图像上进行绘制。Graphics 类封装了Java 支持的基本绘图操作所需的状态信息，主要包括颜色、字体、画笔、文本、图像等。

           Graphics 类提供了绘图常用的方法，利用这些方法可以实现直线、钜形、多边形、椭面、圆弧等形状和文本、图片的绘制操作。另外，在执行这些操作之前，还可以使用相应的方法设置给图的颜色和字体等状态属性。

    Graphics2D类
           使用Graphics 类可以完成简单的图形绘制任务，但是它所实现的功能非常有限，如无法改变线条的粗细、不能对图片使用旋转和模糊等过滤效果。

            Graphics2D 类继承Graphics 类，实现了功能更加强大的绘图操作的集合。由子Graphies2D类是Graphics 类的扩展，也是推荐使用的Java 绘图类。

    说明：Graphics2D 是推荐使用的绘图类，但是程序设计中提供的绘图对象大多是Gmphics 类的实例对象，这时应该使用强制类型转换将其转换为Giraphics2D 类型。

    例如:

    public void paint(Graphics g) {
    Graphics2D g2=(Graphics2D) g;        //制类型转换为Graphics2D 类型

    92......

    }

    绘制图形
    Java 可以分别使用Graphics 类和 Graphics2D 类绘制图形，Graphics类使用不同的方法实现不同图形的给制。例如，drawLine0方法可以绘制直线，drawRectO方法用于绘制矩形，drawOval0方法用于绘制椭圓形等。

    例题19.1

    1. package dishijiuzhang;//例题19.1
    2.  
    3. import java.awt.*;
    4.  
    5. import javax.swing.*;
    6.  
    7. public class DreamCircle extends JFrame{
    8. 	private final int OVAL_WIDTH = 80;		//圆形的宽
    9. 	private final int OVAL_HEIGHT = 80;		//圆形的高
    10. 	
    11. 	public DreamCircle() {
    12. 		initialize();						//调用初始化方法
    13. 	}
    14. 	private void initialize() {								//初始化方法
    15. 		setSize(300,200);									//设置窗体大小
    16. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式
    17. 		setContentPane(new DrawPanel());					//设置窗体面板为绘图面板对象
    18. 		setTitle("绘图实例1");									//设置窗体标题
    19. 	}
    20. 	class DrawPanel extends JPanel {						//创建绘图面板
    21. 		public void paint(Graphics g) {						//重写绘制方法
    22. 			g.drawOval(10, 10, OVAL_WIDTH, OVAL_HEIGHT);	//绘制第一个圆形
    23. 			g.drawOval(80, 10, OVAL_WIDTH, OVAL_HEIGHT);	//绘制第二个圆形
    24. 			g.drawOval(150, 10, OVAL_WIDTH, OVAL_HEIGHT);	//绘制第三个圆形
    25. 			g.drawOval(50, 70, OVAL_WIDTH, OVAL_HEIGHT);	//绘制第四个圆形
    26. 			g.drawOval(120, 70, OVAL_WIDTH, OVAL_HEIGHT);	//绘制第五个圆形
    27. 		}
    28. 		
    29. 	}
    30. 	public static void main(String[] args) {
    31. 		new DreamCircle().setVisible(true);
    32.  
    33. 	}
    34.  
    35. }

    运行结果如下：

    Graphics 类类常用的图形绘制方法图下：

    Graphics2D类是在继承Graphics 类的基础上编写的，它包含了Graphics类的绘图方法并添加了更强的功能，在创建绘图类时推荐使用该类。Graphics2D类可以分别使用不同的类来表示不同的形状，Line2D类、Rectangle2D类等。

           要绘制指定形状的图形，需要先创建并初始化该图形类的对象，且这些图形类必须是Shape接口药实现类；然后使用Graphics2D类的draw0方法绘制该图形对象，或者使用610方法填充该图形对象。看法格式如下:

    draw(Shape form)

    或

    fill(Shape form)

    其中，form 是指实现Shape 接口的对象。

    java.awt.geom 包中提供了如下常用的图形类，这些图形类都实现了Shape 接口：

    Arc2D类
    CubicCurve2D类
    Ellipse2D类
    Line2D类
    Point2D类
    QuadCurve2D类
    Rectangle2D类
    RoundRectangle2D类

    例题19.2

    1. import java.awt.*;
    2. import java.awt.geom.Ellipse2D;
    3. import java.awt.geom.Rectangle2D;
    4.  
    5. import javax.swing.JFrame;
    6. import javax.swing.JPanel;
    7. public class DrawFrame extends JFrame {
    8. 	public DrawFrame(){
    9. 		setTitle("绘图实例2"); // 设置窗体标题 
    10. 		setSize(300,200); // 设置窗体大小
    11. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭模式 
    12. 		add(new CanvasPanel());// 设置窗体面板为绘图面板对象
    13. 	}
    14. 	class CanvasPanel extends JPanel {// 绘图变慢
    15. 		public void paint(Graphics g) {
    16. 			Graphics2D g2 =(Graphics2D) g;
    17. 			Shape[ ] shapes = new Shape[4]; // 声明图形数组
    18. 			shapes[0] = new Ellipse2D.Double(5,5,100,100); // 创建圆形对象
    19. 			shapes[1] = new Rectangle2D.Double(110,5,100,100); // 创建矩形对象 
    20. 			shapes[2] = new Rectangle2D.Double(15,15,80,80);// 创建矩形对象 
    21. 			shapes[3] = new Ellipse2D.Double(120,15,80,80); //创建圆形对象 
    22. 			for (Shape shape : shapes){ // 遍历图形数组
    23. 			Rectangle2D bounds = shape.getBounds2D(); 
    24. 			if (bounds.getWidth() == 80) {
    25. 				Color c1 = new Color(255,0,0);
    26. 				g2.setColor(c1);	
    27. 				g2.fill(shape); // 填充图形
    28. 			}else {
    29. 				Color c1 = new Color(0,0,255);
    30. 				g2.setColor(c1);
    31. 				g2.draw(shape); // 绘制图形
    32. 			}
    33. 			}
    34. 		}
    35. 	}
    36. 			public static void main(String[] args) {
    37. 				new DrawFrame().setVisible(true);
    38. 			}
    39. 		}//例题19.2

    运行结果如下：

    外框粗线

    1. import java.awt.*;
    2. import java.awt.geom.Ellipse2D;
    3. import java.awt.geom.Rectangle2D;
    4.  
    5. import javax.swing.JFrame;
    6. import javax.swing.JPanel;
    7. public class DrawFrame extends JFrame {
    8. 	public DrawFrame(){
    9. 		setTitle("绘图实例2"); // 设置窗体标题 
    10. 		setSize(300,200); // 设置窗体大小
    11. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭模式 
    12. 		add(new CanvasPanel());// 设置窗体面板为绘图面板对象
    13. 	}
    14. 	class CanvasPanel extends JPanel {// 绘图变慢
    15. 		public void paint(Graphics g) {
    16. 			Graphics2D g2 =(Graphics2D) g;
    17. 			Shape[ ] shapes = new Shape[4]; // 声明图形数组
    18. 			shapes[0] = new Ellipse2D.Double(5,5,100,100); // 创建圆形对象
    19. 			shapes[1] = new Rectangle2D.Double(110,5,100,100); // 创建矩形对象 
    20. 			shapes[2] = new Rectangle2D.Double(15,15,80,80);// 创建矩形对象 
    21. 			shapes[3] = new Ellipse2D.Double(120,15,80,80); //创建圆形对象 
    22. 			for (Shape shape : shapes){ // 遍历图形数组
    23. 			Rectangle2D bounds = shape.getBounds2D(); 
    24. 			if (bounds.getWidth() == 80) {
    25. 				Color c1 = new Color(255,0,0);
    26. 				g2.setColor(c1);	
    27. 				g2.fill(shape); // 填充图形
    28. 			}else {
    29. 				Color c1 = new Color(0,0,255);
    30. 				g2.setColor(c1);
    31. 				BasicStroke bs = new BasicStroke(5,0,1);
    32. 				g2.setStroke(bs);
    33. 				g2.draw(shape); // 绘制图形
    34. 			}
    35. 			}
    36. 		}
    37. 	}
    38. 			public static void main(String[] args) {
    39. 				new DrawFrame().setVisible(true);
    40. 			}
    41. 		}//例题19.2

    运行结果如下：

    绘图颜色与画笔属性
    设置颜色
           使用Color 类可以创建任意颜色的对象，不用担心平台是否支持该颜色，因为Java以跨平台和与硬件无关的方式支持颜色管理。创建Color 对象的构造方法有如下两种：

    Color col = new Color(int r, int g, int b)

    Color col = new Color(int rgb)

    rgb：颜色值，该值是红、绿、蓝三原色的总和。
    r：该参数是三原色中红色的取值。
    g：该参数是三原色中绿色的取值。
    b：该参数是三原色中蓝色的取值。
     Color 类定义了常用色彩的常量值，如表 19.2 所示。这些常量都是静态的Color 对象，可以意接使用这些常量值定义的颜色对象。

    绘图类可以使用setColor()方法设置当前颜色。语法如下：

    setColor(Color color)

    其中，参数color是Color对象，代表一个颜色值，如红色、黄色或默认的黑色

    例如，设置当前绘图颜色为红色的代码如下：

    public void paint(Graphics g){
            Graphics2D g2 =(Graphics2D) g;

            g.setColo(Color.RED);

            ...

    }

    设置画笔 
           默认情况下，Graphics 类使用的画笔属性是粗细为1个像素的正方形，而Graphics2D类可以调用setStrokeO方法设置画笔的属性，如改变线条的粗细、虚实，定义线段端点的形状、风格等。语法格式如下：

    setStroke(Stroke stroke)

    其中，参数stroke是Stroke 接口的实现类对象。

          setStroke0方法必须接受一个 Stroke 接口的实现类对象作参数，java.awrt包中提供了BasisSrke类它实现了Stroke接口，并且通过不同的构造方法创建画笔属性不同的对象。这些构造方法如下：

    BasicStroke（）
    BasicStroke(float width)
    BasicStroke(float width, int cap, int join)
    BasicStroke(float width, int cap, int join, float miterlimit)
    BasicStroke(float width, int cap, int join, float miterlimit, float[] dash, float dash_phase 
    这些构造方法中的参数说明如表19.3所示。

    绘制文本
    设置字体
    Java 使用Font 类封装了字体的大小、样式等属性，该类在java.awt包中定义，其构造方法可以指定字体的名称、大小和样式3个属性。语法如下:

    Font(String name, int style, int size)

    name：字体的名称
    style：字体的样式
    size：字体的大小 
    设置绘图类的字体可以使用绘图类的setFontO方法。设置字体以后在图形上下文中绘制的所有文字都使用该字体，除非再次设置其他字体。语法如下：

    setFont(Font font)

    其中，参数font 是Font 类的字体对象。 

    显示文字
    Graphics2D类提供了drawString0方法，使用该方法可以实现图形上下文的文本绘制，从而实现在图片上显示文字的功能。语法格式有如下两种：

    1.drawString(String str, int x, int y)
    2.drawString(String str, float x, float y)

    str：要绘制的文本字符串。
    x：绘制字符串的水平起始位置。
    y：绘制字符串的垂直起始位置。
    这两个方法唯一不同的就是x和y的参数类型不同。

    例题19.3

    1. import java.awt.*;
    2. import java.awt.geom.Rectangle2D;
    3. import java.util.Date;
    4. import javax.swing.*;
    5.  
    6. public class DrawString extends JFrame{
    7. 	public DrawString() {
    8. 		setSize(230,140);									//设置窗体大小
    9. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式
    10. 		add(new CanvasPanel());								//设置窗体面板为绘图面板对象
    11. 		setTitle("绘图文本");									//设置窗体标题
    12. 	}
    13. 	class CanvasPanel extends JPanel {
    14. 		public void paint(Graphics g) {
    15. 			Graphics2D g2 =(Graphics2D) g;
    16. 		Rectangle2D rect = new Rectangle2D.Double(10,10,200,80);
    17. 		Font font = new Font("宋体",Font.BOLD,16);
    18. 		Date date = new Date();
    19. 		g2.setColor(Color.CYAN);							//设置当前绘图颜色
    20. 		g2.fill(rect);										//填充矩形
    21. 		g2.setColor(Color.BLUE);							//设置当前绘图颜色
    22. 		g2.setFont(font);									//设置字体	
    23. 		g2.drawString("现在时间是",20,30);						//绘制文本
    24. 		g2.drawString(String.format("%tr",date),50,60);		//绘制时间文本
    25. 	}
    26. }
    27. 	public static void main(String[] args) {
    28. 		new DrawString().setVisible(true);
    29. 	}
    30.  
    31. }//例题19.3

    运行结果如下：

    显示图片 
            绘图类不仅可以绘制图形和文本，还可以使用drawImageO方法将图片资源显示到绘图上下文中，而且可以实现各种特效处理，如图片的缩放、翻转等。有关图像处理的知识将在19.6节讲解，本节主要讲解如何显示图片。语法如下：

    drawimage(lmage img, int x, int y, ImageObserver observer)

    该方法将img 图片显示在x、y指定的位置上。方法中涉及的参数说明如下所示

    drawimage0方法的使用与绘制文本的drawStringO方法类似，唯一不同的是该方法需要指定要通知

    的图像观察者。

    例题19.4

    1.  
    2. import java.awt.*;
    3. import java.io.*;
    4.  
    5. import javax.imageio.ImageIO;
    6. import javax.swing.*;
    7.  
    8. public class DrawImage extends JFrame{
    9. 	Image img;												//展示图片
    10. 	
    11. 	public DrawImage() {
    12. 		try {
    13. 			img = ImageIO.read(new File("src/img.jpg"));	//读取图片文件
    14. 		}catch (IOException e) {
    15. 			e.printStackTrace();
    16. 		}
    17. 		setSize(440,300);									//设置窗体大小
    18. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式
    19. 		add(new CanvasPanel());								//设置窗体面板为绘图面板对象
    20. 		setTitle("绘制图片");									//设置窗体标题
    21. 	}
    22. 	class CanvasPanel extends JPanel {
    23. 		public void paint(Graphics g) {
    24. 			Graphics2D g2 =(Graphics2D) g;
    25. 			g2.drawImage(img,0,0,this);						//显示图片
    26. 		}
    27. 	}
    28.  
    29. 	public static void main(String[] args) {
    30. 		new DrawImage().setVisible(true);
    31.  
    32. 	}
    33.  
    34. }//例题19.4

    运行结果如下：

    图像处理 
           开发高级的桌面应用程序，必须掌握一些图像处理与动画制作的技术，如在程序中显示统计图、销售趋势图、动态按钮等。

    放大与缩小
    在显示图片时，使用了drawImageO方法将图片以原始大小显示在窗体中，要想实现图片的放大与缩小，则需要使用它的重载方法。语法如下：

    drawlmage(lmage img, int x, int y, int width, int height, ImageObserver observer)

    该方法将img图片显示在x、y指定的位置上，并指定图片的宽度和高度属性。方法中涉及的参数说明如表19.5所示。

    例题19.5

    1. import java.awt.*;
    2. import java.io.*;
    3.  
    4. import javax.imageio.ImageIO;
    5. import javax.swing.*;
    6.  
    7. import javax.swing.event.*;
    8.  
    9. public class ImageZoom extends JFrame{
    10. 	Image img;
    11. 	private int imgWidth,imgHeight;
    12. 	private JSlider jSlider;
    13. 	public ImageZoom() {
    14. 		try {
    15. 			img = ImageIO.read(new File("src/img.jpg"));	//读取图片文件
    16. 		}catch (IOException e) {
    17. 			e.printStackTrace();
    18. 		}
    19. 		CanvasPanel canvas = new CanvasPanel();
    20. 		jSlider = new JSlider();
    21. 		jSlider.setMaximum(1000);
    22. 		jSlider.setValue(100);
    23. 		jSlider.setMinimum(1);
    24. 		jSlider.addChangeListener(new ChangeListener(){
    25. 			public void stateChanged(ChangeEvent e) {
    26. 				canvas.repaint();
    27. 			}
    28. 		});
    29. 		
    30. 		JPanel center = new JPanel();
    31. 		center.setLayout(new BorderLayout());
    32. 		center.add(jSlider, BorderLayout.SOUTH);
    33. 		center.add(canvas, BorderLayout.CENTER);
    34. 		setContentPane(center);
    35. 		setBounds(100, 100, 800, 600);						//设置窗体大小和位置
    36. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式
    37. 		setTitle("绘制图片");
    38. 	}
    39. 	
    40. 	class CanvasPanel extends JPanel {
    41. 		public void paint(Graphics g){
    42. 		int newW = 0, newH = 0;
    43. 		imgWidth= img.getWidth(this);						//获取图片宽度
    44. 		imgHeight = img.getHeight(this);					//获取图片高度
    45. 		float value = jSlider.getValue();					//滑块组件的取值
    46. 		newW = (int)(imgWidth *value / 100);				//计算图片放大后的宽度
    47. 		newH=(int) (imgHeight* value /100);					//计算图片放大后的高度
    48. 		g.drawImage(img, 0, 0, newW, newH, this);			//绘制指定大小的图片
    49. 		}
    50. 	}
    51. 		public static void main(String[] args){
    52. 		new ImageZoom().setVisible(true);
    53. 		}
    54. 	}//例题19.5

    运行结果如下：

    图像翻转 
    图像的翻转需要使用drawImage()方法的另一个重载方法。语法如下:

    drawimage(lmage img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)

    此方法总是用非缩放的图像来呈现缩放的矩形，并动态地执行所需的缩放。此操作不使用缓存的缩放图像。执行图像从源到目标的缩放，要将源矩形的第一个坐标映射到目标矩形的第一个坐标，源矩形的第二个坐标映射到目标矩形的第二个坐标，按需要缩放和翻转子图像，以保持这些映射关系。方法中涉及的参数说明如表19.6所示。

    例题19.6

    1.  
    2. import java.awt.*;
    3. import java.awt.event.*;
    4. import java.io.*;
    5. import javax.swing.*;
    6. import javax.imageio.ImageIO;
    7.  
    8. public class PartImage extends JFrame {
    9. 	private Image img;
    10. 	private int dx1, dy1, dx2, dy2;
    11. 	private int sx1, sy1, sx2, sy2;
    12. 	private int width = 300, height = 200;// 图片宽高
    13. 	private JButton vBtn = null;// 垂直翻转按钮
    14. 	private JButton hBtn = null;// 水平翻转按钮
    15. 	private CanvasPanel canvasPanel = null;
    16.  
    17. 	public PartImage() {
    18.  
    19. 		try {
    20. 			img = ImageIO.read(new File("src/img.jpg"));// 读取图片文件
    21. 		} catch (IOException e) {
    22. 			e.printStackTrace();
    23. 		}
    24. 		dx2 = sx2 = width; // 初始化图像大小
    25. 		dy2 = sy2 = height;
    26.  
    27. 		vBtn = new JButton("垂直翻转");
    28. 		hBtn = new JButton("水平翻转");
    29.  
    30. 		JPanel bottom = new JPanel();
    31. 		bottom.add(hBtn);
    32. 		bottom.add(vBtn);
    33.  
    34. 		Container c = getContentPane();
    35. 		c.add(bottom, BorderLayout.SOUTH);
    36. 		canvasPanel = new CanvasPanel();
    37. 		c.add(canvasPanel, BorderLayout.CENTER);
    38.  
    39. 		addListener();
    40.  
    41. 		setBounds(100, 100, 300, 260); // 设置窗体大小和位置
    42. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭模式
    43. 		setTitle("图片翻转"); // 设置窗体标题
    44. 	}
    45.  
    46. 	private void addListener() {
    47. 		vBtn.addActionListener(new ActionListener() {
    48. 			public void actionPerformed(ActionEvent e) {
    49. 				sy1 = Math.abs(sy1 - height);// 纵坐标互换
    50. 				sy2 = Math.abs(sy2 - height);
    51. 				canvasPanel.repaint();
    52. 			}
    53. 		});
    54. 		hBtn.addActionListener(new ActionListener() {
    55. 			public void actionPerformed(ActionEvent e) {
    56. 				sx1 = Math.abs(sx1 - width);// 横坐标互换
    57. 				sx2 = Math.abs(sx2 - width);
    58. 				canvasPanel.repaint();
    59. 			}
    60. 		});
    61. 	}
    62.  
    63. 	class CanvasPanel extends JPanel {
    64. 		public void paint(Graphics g) {
    65. 			g.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);// 绘制指定大小的图片
    66. 		}
    67. 	}
    68.  
    69. 	public static void main(String[] args) {
    70. 		new PartImage().setVisible(true);
    71. 	}
    72. }//19.6

    运行结果如下：

    图像旋转 
    图像旋转需要调用Graphics2D类的rotateO方法，该方法将根据指定的弧度旋转图像。语法如下：

    rotate(double theta)

    其中，theta 是指旋转的弧度

    例题19.7

    1. import java.awt.*;
    2. import java.io.*;
    3. import javax.swing.*;
    4. import javax.imageio.ImageIO;
    5.  
    6. public class RotateImage extends JFrame{
    7. 	private Image img;
    8. 	public RotateImage(){
    9. 		try{
    10. 			img = ImageIO.read(new File("src/img.jpg"));	//读取图片文件
    11. 		}catch (IOException e) {
    12. 			e.printStackTrace();
    13. 		}
    14. 		setBounds(100, 100, 400, 350);						//设置窗体大小和位置
    15. 		add(new CanvasPanel());
    16. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式1
    17. 		setTitle("图片旋转");									//设置窗体标题
    18. 		}
    19. 		class CanvasPanel extends JPanel {
    20. 			public void paint(Graphics g) {
    21. 			Graphics2D g2 =(Graphics2D) g;
    22. 			g2.rotate(Math.toRadians(5));					//旋转5°
    23. 			g2.drawImage(img,70, 10, 300, 200, this);
    24. 			g2.rotate(Math.toRadians(5));
    25. 			g2.drawImage(img,70, 10, 300, 200, this);
    26. 			g2.rotate(Math.toRadians(5));
    27. 			g2.drawImage(img, 70, 10, 300, 200, this);
    28. 			}
    29. 		}
    30. 			
    31. 		public static void main(String[] args) {
    32. 			new RotateImage().setVisible(true);
    33. 		}
    34. 	}//例题19.7

    运行结果如下：

    图像倾斜 
    可以使用Graphics2D类提供的shearO方法设置绘图的倾斜方向，从而使图像实现倾斜的效果。语法如下:

    shear(double shx, double shy) 

    shx：水平方向的倾斜量
    shy : 垂直方向的倾斜量

    例题19.8

    1. import java.awt.*;
    2. import java.io.*;
    3. import javax.swing.*;
    4. import javax.imageio.ImageIO;
    5.  
    6. public class TiltImage extends JFrame{
    7. 	private Image img;
    8. 	
    9. 	public TiltImage() {
    10. 		try{
    11. 			img= ImageIO.read(new File("src/img.jpg"));			//读取图片文件
    12. 			} catch (IOException e){
    13. 				e.printStackTrace();
    14. 			}
    15. 			setBounds(100, 100, 400, 300);						//设置窗体大小和位置
    16. 			add(new CanvasPanel());
    17. 			setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		//设置窗体关闭模式
    18. 			setTitle("图片倾斜");									//设置窗体标题
    19. 	}
    20. 		class CanvasPanel extends JPanel {
    21. 			public void paint(Graphics g) {
    22. 				Graphics2D g2 =(Graphics2D) g;
    23. 				g2.shear(0.3, 0);								//倾斜30%
    24. 				g2.drawImage(img, 0, 0, 300, 200, this);
    25. 			}
    26. 		}
    27. 		public static void main(String[] args) {
    28. 			new TiltImage().setVisible(true);
    29. 		}
    30. 	}//例题19.8

    运行结果如下：

  • 相关阅读:
    JSX 中使用 js 表达式
    js html生成图片
    Python的内存优化
    数字政府应用场景中数据安全体系
    事务的概念-事务的概念、事务的定义（BEGIN TRANSACTION、COMMIT、ROLLBACK）
    如何理解Go言中的Context?
    【如何学习CAN总线测试】——CAN交互层测试
    讲讲URL与URI的区别
    C++ 常用数学函数详解汇总#include＜cmath＞
    Kotlin高仿微信-第16篇-单聊-红包
  • 原文地址：https://blog.csdn.net/hb20021005/article/details/134432176