offscreentest.java

来自「java learn PPT java learn PPT java learn」· Java 代码 · 共 214 行

     import java.applet.*;
     import java.awt.*;
     import java.awt.geom.*; 
     import java.awt.event.*;
     import java.util.*;
       
     public class OffscreenTest extends Frame implements KeyListener, Runnable
     {  
          // 动画线程
          private Thread animation;

          // 画面中所包含的矩形的数目
          private final int NUM_RECTS = 10;

          // 矩形队列
          private LinkedList rectangles;
          private ListIterator iterator;

          // 显示半透明矩形的AlphaCompisite
          private AlphaComposite alpha;          
         
          // 当前所选择的矩形的索引
          private int curr;

          // 运动的矩形的当前位置
          private double vx;
          private double vy;

          // 为屏外绘制准备的屏外图像
          Image offscreen;
         
          public OffscreenTest(){
          	init();
          }
          public void init()
          {
          	   setSize(400,300);
          	   setVisible(true);
               animation = new Thread(this);

               rectangles = new LinkedList();

               // 创建屏外绘制图像
               offscreen = createImage(getSize().width, getSize().height);

               // 用50%的透明度创建一个AlphaComposite
               alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);

               // 在随机位置创建 NUM_RECTS个矩形并把它们添加到队列中
               Random r = new Random();
               int width  = (int)getSize().getWidth();
               int height = (int)getSize().getHeight();

               for(int i = 0; i < NUM_RECTS; i++)
               {
                    rectangles.add(new Rectangle2D.Double(
                           (double)(   Math.abs(r.nextInt())%width),
                           (double)(   Math.abs(r.nextInt())%height),
                           (double)(20+Math.abs(r.nextInt())%50), 
                           (double)(20+Math.abs(r.nextInt())%50)));
               } 
               curr = 0;

               vx = vy = 6;

               // 不要忘记注册applet来监听键盘事件
               addKeyListener(this);
          }

          public void update(Graphics g)
          {
               // 更新当前矩形
               double x, y, w, h;

               Rectangle2D active = (Rectangle2D)rectangles.get(curr);

               x = active.getX()+vx;
               y = active.getY()+vy;
               w = active.getWidth();
               h = active.getHeight();

               if(x < 0)
               {
                    x = 0;
                    vx = - vx;                    
               }
               else if(x + w > getSize().width) 
               {
                    x = getSize().width - w;
                    vx = - vx;
               }

               if(y < 0)
               {
                    y = 0;
                    vy = - vy;
               }
               else if(y + h > getSize().height) 
               {
                    y = getSize().height - h;
                    vy = - vy;
               }

               active.setRect(x, y, w, h);

               // 确保我们有一个有效的屏外图像             
               if(offscreen == null || 
                  offscreen.getWidth(null)  != getSize().width || 
                  offscreen.getHeight(null) != getSize().height)
               {
                    offscreen = createImage(getSize().width, getSize().height);
               }
             
               paint(g);
          }
          
          public static void main(String[] args){
          	new OffscreenTest().start();
          }

          public void paint(Graphics g)
          {
               Graphics2D g2d = (Graphics2D)offscreen.getGraphics();
               g2d.setPaint(Color.WHITE);
               g2d.fillRect(0, 0, getSize().width, getSize().height);

               // 告诉Graphics2D容器使用透明度
               g2d.setComposite(alpha);

               // 绘制矩形
               g2d.setPaint(Color.BLACK);
               for(int i = 0; i < NUM_RECTS; i++)
               {
                    g2d.draw((Rectangle2D)rectangles.get(i));
               }
 
               Rectangle2D rect;
               Rectangle2D active = (Rectangle2D)rectangles.get(curr);
               g2d.setPaint(Color.RED.darker());
               for(iterator = rectangles.listIterator(0); iterator.hasNext(); )
               {
                    // 获得队列中的下一个矩形
                    rect = (Rectangle2D)iterator.next();
                                
                    // 检测重叠--注意我们不应该检测所选取的矩形和它自身的重叠
                    if(active != rect && active.intersects(rect))
                    {
                         // 填充重叠部分
                         g2d.fill(rect);
                    }                                          
               }
               
               // 填充所选取的矩形
               g2d.setPaint(Color.BLUE.brighter());
               g2d.fill(active);

               // 在用完后回收Graphics2D容器
               g2d.dispose();

               // 在可见的Graphics容器上绘制最终的屏外图像             
               g.drawImage(offscreen, 0, 0, this);
          }

          public void start()
          {
              // 启动动画线程
              animation = new Thread(this);
              animation.start();
          }

          public void stop() 
          {
              animation = null;
          }

          public void run() 
          {
               Thread t = Thread.currentThread();
	       while (t == animation)
               {
                    try
                    {  
                         Thread.sleep(33);
                    }
                    catch(InterruptedException e) 
                    {
                         break;
                    }

                    repaint();
                }              
          }   // run

          public void keyPressed(KeyEvent e) 
          {
          }

          public void keyReleased(KeyEvent e) 
          {
          }

          public void keyTyped(KeyEvent e)  
          {
               // 如果按下空格键则在矩形之间循环
               if(e.getKeyChar() == KeyEvent.VK_SPACE)
               {    
                    if(++curr >= rectangles.size())
                    {
                         curr = 0;
                    }
               } 
          }

     }    // CollisionTest