疯狂JAVA讲义---第十一章（下）：AWT编程-高级应用

这章我们主要来讨论下用awt包画图，位图处理，使用剪贴板等，由于这些东西比较有套路，我主要以代码形式讲解。

绘图主要是利用Component的三个方法，

paint(Graphics g):绘制组件的外观

update(Graphic g):调用paint方法刷新外观

repaint():调用update

1. public class SimpleDraw
2. {
3.     private final String RECT_SHAPE = "rect";
4.     private final String OVAL_SHAPE = "oval";
5.     private Frame f = new Frame("简单绘图");
6.     private Button rect = new Button("绘制矩形");
7.     private Button oval = new Button("绘制圆形");
8.     private MyCanvas drawArea = new MyCanvas();
9.     //用于保存需要绘制什么图形的字符串属性
10.     private String shape = "";
11.     public void init()
12.     {
13.         Panel p = new Panel();
14.         rect.addActionListener(new ActionListener()
15.         {
16.             public void actionPerformed(ActionEvent e)
17.             {
18.                 //设置shape属性为RECT_SHAPE
19.                 shape = RECT_SHAPE;
20.                 //重画MyCanvas对象，即调用它的update方法
21.                 drawArea.repaint();
22.             }
23.         });
24.         oval.addActionListener(new ActionListener()
25.         {
26.             public void actionPerformed(ActionEvent e)
27.             {
28.                 //设置shape属性为OVAL_SHAPE
29.                 shape = OVAL_SHAPE;
30.                 //重画MyCanvas对象，即调用它的update方法
31.                 drawArea.repaint();
32.             }
33.         });
34.         p.add(rect);
35.         p.add(oval);
36.         drawArea.setPreferredSize(new Dimension(250 , 180));
37.         f.add(drawArea);
38.         f.add(p , BorderLayout.SOUTH);
39.         f.pack();
40.         f.setVisible(true);
41.     }
43.     public static void main(String[] args) 
44.     {
45.         new SimpleDraw().init();
46.     }
47.     class MyCanvas extends Canvas
48.     {
49.         //重写Canvas的paint方法，实现绘画
50.         public void paint(Graphics g)
51.         {
52.             Random rand = new Random();
53.             if (shape.equals(RECT_SHAPE))
54.             {
55.                 //设置画笔颜色
56.                 g.setColor(new Color(220, 100, 80));
57.                 //随机地绘制一个矩形框
58.                 g.drawRect( rand.nextInt(200) , rand.nextInt(120) , 40 , 60);
59.             }
60.             if (shape.equals(OVAL_SHAPE))
61.             {
62.                 //设置画笔颜色
63.                 g.setColor(new Color(80, 100, 200));
64.                 //随机地绘制一个矩形框
65.                 g.fillOval( rand.nextInt(200) , rand.nextInt(120) , 50 , 40);
66.             }
67.         }
68.     }
69. }

下面讲个利用BufferedImage实现图形缓冲的例子，eg

1. public class HandDraw
2. {
3.     //画图区的宽度 
4.     private final int AREA_WIDTH = 500;
5.     //画图区的高度
6.     private final int AREA_HEIGHT = 400;
7.     //下面的preX、preY保存了上一次鼠标拖动事件的鼠标座标
8.     private int preX = -1;
9.     private int preY = -1;
10.     //定义一个右键菜单用于设置画笔颜色
11.     PopupMenu pop = new PopupMenu();
12.     MenuItem redItem = new MenuItem("红色");
13.     MenuItem greenItem = new MenuItem("绿色");
14.     MenuItem blueItem = new MenuItem("蓝色");
15.     //定义一个BufferedImage对象
16.     BufferedImage image = new BufferedImage(AREA_WIDTH , AREA_HEIGHT , 
17.         BufferedImage.TYPE_INT_RGB);
18.     //获取image对象的Graphics
19.     Graphics g = image.getGraphics();
20.     private Frame f = new Frame("简单手绘程序");
21.     private DrawCanvas drawArea = new DrawCanvas();
22.     //用于保存需要绘制什么图形的字符串属性
23.     private String shape = "";
24.     //用于保存画笔颜色
25.     private Color foreColor = new Color(255, 0 ,0);
26.     public void init()
27.     {
28.         //定义右键菜单的事件监听器。
29.         ActionListener menuListener = new ActionListener()
30.         {
31.             public void actionPerformed(ActionEvent e)
32.             {
33.                 if (e.getActionCommand().equals("绿色"))
34.                 {
35.                     foreColor = new Color(0 , 255 , 0);
36.                 }
37.                 if (e.getActionCommand().equals("红色"))
38.                 {
39.                     foreColor = new Color(255 , 0 , 0);
40.                 }
41.                 if (e.getActionCommand().equals("蓝色"))
42.                 {
43.                     foreColor = new Color(0 , 0 , 255);
44.                 }
45.             }
46.         };
47.         //为三个菜单添加事件监听器
48.         redItem.addActionListener(menuListener);
49.         greenItem.addActionListener(menuListener);
50.         blueItem.addActionListener(menuListener);
51.         //将菜单项组合成右键菜单
52.         pop.add(redItem);
53.         pop.add(greenItem);
54.         pop.add(blueItem);
55.         //将右键菜单添加到drawArea对象中
56.         drawArea.add(pop);
57.         //将image对象的背景色填充成白色
58.         g.fillRect(0 , 0 ,AREA_WIDTH , AREA_HEIGHT);
59.         drawArea.setPreferredSize(new Dimension(AREA_WIDTH , AREA_HEIGHT));
60.         //监听鼠标移动动作
61.         drawArea.addMouseMotionListener(new MouseMotionAdapter()
62.         {
63.             //实现按下鼠标键并拖动的事件处理器
64.             public void mouseDragged(MouseEvent e)
65.             {
66.                 //如果preX和preY大于0
67.                 if (preX > 0 && preY > 0)
68.                 {
69.                     //设置当前颜色
70.                     g.setColor(foreColor);
71.                     //绘制从上一次鼠标拖动事件点到本次鼠标拖动事件点的线段
72.                     g.drawLine(preX , preY , e.getX() , e.getY());
73.                 }
74.                 //将当前鼠标事件点的X、Y座标保存起来
75.                 preX = e.getX();
76.                 preY = e.getY();
77.                 //重绘drawArea对象
78.                 drawArea.repaint();
79.             }
80.         });
81.         //监听鼠标事件
82.         drawArea.addMouseListener(new MouseAdapter()
83.         {
84.             //实现鼠标松开的事件处理器
85.             public void mouseReleased(MouseEvent e)
86.             {
87.                 //弹出右键菜单
88.                 if (e.isPopupTrigger())
89.                 {
90.                     pop.show(drawArea , e.getX() , e.getY());
91.                 }
92.                 //松开鼠标键时，把上一次鼠标拖动事件的X、Y座标设为-1。
93.                 preX = -1;
94.                 preY = -1;
95.             }
96.         });
97.         f.add(drawArea);
98.         f.pack();
99.         f.setVisible(true);
100.     }
101.     public static void main(String[] args) 
102.     {
103.         new HandDraw().init();
104.     }
105.     class DrawCanvas extends Canvas
106.     {
107.         //重写Canvas的paint方法，实现绘画
108.         public void paint(Graphics g)
109.         {
110.             //将image绘制到该组件上
111.             g.drawImage(image , 0 , 0 , null);
112.         }
113.     }
114. }

 

 

 

由于以上每次画都刷全图，闪烁还是不能避免，其实只要刷画笔的周围就可以实现基本不闪的效果，利用Swing的JPanel组件等都已经实现了双缓冲了

下面再讲下利用ImageIO来对图片进行读写，在windows现在支持这几种图片格式
BMP
jpeg
bmp
wbmp
gif
JPG
png
jpg
JPEG
WBMP

常用的基本都支持了，举个使用实例eg

1. public class ZoomImage
2. {
3.     //下面两个常量设置缩小后图片的大小
4.     private final int WIDTH = 80;
5.     private final int HEIGHT = 60;
6.     //定义个BuffedImage对象，用于保存缩小后的位图
7.     BufferedImage image = new BufferedImage(WIDTH , HEIGHT , 
8.         BufferedImage.TYPE_INT_RGB);
9.     Graphics g = image.getGraphics();
10.     public void zoom()throws Exception
11.     {
12.         //读取原始位图
13.         Image srcImage = ImageIO.read(new File("image/board.jpg"));
14.         //将原始位图缩小后绘制到image图象中
15.         g.drawImage(srcImage , 0 , 0 , WIDTH , HEIGHT , null);
16.         //将image图象文件输出到磁盘文件中。
17.         ImageIO.write(image , "jpeg" , 
18.             new File(System.currentTimeMillis() + ".jpg"));
19.     }
20.     public static void main(String[] args)throws Exception
21.     {
22.         new ZoomImage().zoom();
23.     }
24. }

最后简单讲下剪贴板的使用，主要区别下系统剪贴板和本地剪贴板的区别，本地的复制只能在jvm里使用。eg

1. public class SimpleClipboard
2. {
3.     private Frame f = new Frame("简单的剪贴板程序");
4.     //获取系统剪贴板
5.     private Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); 
6.     //下面是创建本地剪贴板的代码
7.     //Clipboard clipboard = new Clipboard("cb"); 
8.     //用于复制文本的文本框
9.     private TextArea jtaCopyTo = new TextArea(5,20); 
10.     //用于粘贴文本的文本框
11.     private TextArea jtaPaste = new TextArea(5,20);
12.     private Button btCopy = new Button("复制"); //拷贝按钮
13.     private Button btPaste = new Button("粘贴"); //粘贴按钮 
14.     public void init()
15.     {
16.         Panel p = new Panel();
17.         p.add(btCopy);
18.         p.add(btPaste);  
19.         btCopy.addActionListener(new ActionListener()
20.         {
21.             public void actionPerformed(ActionEvent event)
22.             {
23.                 //将一个多行文本域里的字符串封装成StringSelection对象
24.                 StringSelection contents=new StringSelection(jtaCopyTo.getText());
25.                 //将StringSelection对象放入剪贴板
26.                 clipboard.setContents(contents, null); 
27.             }
28.         });
29.         btPaste.addActionListener(new ActionListener()
30.         {
31.             public void actionPerformed(ActionEvent event)
32.             {
33.                 //如果剪贴板中包含stringFlavor内容
34.                 if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor))
35.                 {
36.                     try
37.                     {
38.                         //取出剪贴板中stringFlavor内容
39.                         String content = (String)clipboard.getData(DataFlavor.stringFlavor);
40.                         jtaPaste.append(content);
41.                     }
42.                     catch (Exception e)
43.                     {
44.                         e.printStackTrace();
45.                     }
47.                 }
48.             }
49.         }); 
50.         //创建一个水平排列的Box容器
51.         Box box = new Box(BoxLayout.X_AXIS);
52.         //将两个多行文本域放在Box容器中
53.         box.add(jtaCopyTo);
54.         box.add(jtaPaste);
55.         //将按钮所在Panel、Box容器添加到Frame窗口中
56.         f.add(p,BorderLayout.SOUTH); 
57.         f.add(box,BorderLayout.CENTER);
58.         f.pack();
59.         f.setVisible(true);
60.     }
61.     public static void main(String[] args)
62.     {
63.         new SimpleClipboard().init(); 
64.     }
65. }