JAVA双缓冲机制

最新推荐文章于 2021-02-25 06:47:10 发布
最新推荐文章于 2021-02-25 06:47:10 发布
阅读量2.5k 收藏 5
点赞数 1
分类专栏： java 文章标签： java

http://stchou.iteye.com/blog/810701

以前都不了解双缓冲是什么个东东，

 

但是为了解决我的坦克大战疯狂的闪屏

 后，终于对其有了一个了解。

Java代码   收藏代码
  1. package My2;  
  2.   
  3. import java.awt.Color;  
  4. import java.awt.Graphics;  
  5. import java.awt.Image;  
  6. import java.awt.event.KeyEvent;  
  7. import java.awt.event.WindowAdapter;  
  8. import java.awt.event.WindowEvent;  
  9. import java.util.ArrayList;  
  10. import java.util.List;  
  11.   
  12. import javax.tools.JavaCompiler;  
  13.   
  14.   
  15.   
  16.   
  17. public class tankGame extends java.awt.Frame implements java.awt.event.KeyListener{  
  18.     //窗体宽度  
  19.     public static final int WINDOW_WIDTH = 800;  
  20.     //窗体高度  
  21.     public static final int WINDOW_HEIGHT = 600;  
  22.     //窗体刷新率  
  23.     public static final int REFRESH_RATE = 50;  
  24.     //玩家坦克  
  25.     static Tank myTank = null;  
  26.     // 坦克起始位置左上角坐标  
  27.     public static final int Tank_X = 385;  
  28.     public static final int Tank_Y = 550;  
  29.     //敌方坦克同时出现的最大数量  
  30.     private int tankMaxNum = 10;  
  31.     //当前敌方坦克数量  
  32.     private int tankNum = 0;  
  33.     //存放敌方坦克的容器  
  34.     static List<Tank> enemyTanks = new ArrayList<Tank>();  
  35.     //存放墙的容器  
  36.     static List<Wall> wallList = new ArrayList<Wall>();  
  37.     static int wallNum=35;  
  38.     //屏幕画布  
  39.     static java.awt.Graphics g = null;  
  40.     Image offScreenImage = null;  
  41.   
  42.       
  43.       
  44.     public static void main(String[] args){  
  45.         tankGame game = new tankGame();  
  46.           
  47.         game.showUI();  
  48.         game.Init();  
  49.         game.addKeyListener(game);  
  50.     }  
  51.       
  52.       
  53.     public void paint(java.awt.Graphics g){  
  54.         drawTank();  
  55.     }  
  56.       
  57.       
  58.     public static void drawTank(){  
  59.   
  60.         if(myTank==null) return ;  
  61.         g.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);    
  62.         myTank.draw(g);  
  63.         for (int i=0;i<enemyTanks.size();i++){  
  64.             enemyTanks.get(i).draw(g);  
  65.         }  
  66.           
  67.         for (int i=0;i<wallList.size();i++){  
  68.             wallList.get(i).draw(g);  
  69.         }  
  70.     }  
  71.       
  72.     public void Init(){  
  73.         //加入我方坦克  
  74.         myTank = new Tank(Tank_X,Tank_Y,true,0);  
  75.         myTank.draw(g);  
  76.           
  77.         //加入敌方坦克  
  78.         for (int i = 0; i < tankMaxNum; i++) {  
  79.             Tank enemyTank = new Tank(200 + 50 * i, 100, false, 1);  
  80.             enemyTanks.add(enemyTank);  
  81.             tankNum++;  
  82.         }  
  83.           
  84. //        加入城墙  
  85.         for (int i=0;i<wallNum;i++){  
  86.             Wall wall = new Wall(100+i*18,300);  
  87.             wallList.add(wall);  
  88.             wall = new Wall(100+i*18,318);  
  89.             wallList.add(wall);  
  90.         }  
  91.           
  92.          // 启动重画线程  
  93.         PaintThread pt = new PaintThread();  
  94.         Thread t = new Thread(pt);  
  95.         t.start();  
  96.     }  
  97.       
  98.     /** 
  99.      * 显示窗体 
  100.      */  
  101.     public void showUI(){  
  102.         this.setTitle("我打坦克大战");  
  103.         this.setLocation(200, 100);  
  104.         this.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);  
  105.            this.setResizable(false);  
  106.             this.addWindowListener(  
  107.                 new WindowAdapter() {  
  108.                     public void windowClosing(WindowEvent e) {  
  109.                         setVisible(false);  
  110.                         System.exit(0);  
  111.                     }  
  112.                 }  
  113.             );  
  114.         this.setBackground(Color.BLACK);  
  115.         this.setVisible(true);  
  116.         g=this.getGraphics();  
  117.     }  
  118.       
  119.       
  120.       /** 
  121.      * 重写update方法,先将窗体上的图形画在图片对象上，再一次性显示 
  122.      */  
  123. //    public void update(Graphics g) {  
  124. //       if (offScreenImage == null) {  
  125. //             offScreenImage = this.createImage(WINDOW_WIDTH,  
  126. //                     WINDOW_HEIGHT);  
  127. //            }  
  128. //            Graphics gOffScreen = offScreenImage.getGraphics();// 获取图片内的所有图形，形成虚拟窗口  
  129. //            Color c = gOffScreen.getColor();  
  130. //            gOffScreen.setColor(Color.BLACK);// 设置屏幕窗口的颜色  
  131. //            gOffScreen.fillRect(0, 0, WINDOW_WIDTH,WINDOW_HEIGHT);  
  132. //            gOffScreen.setColor(c);  
  133. //            paint(gOffScreen); // 把虚拟窗口画在图片上  
  134. //            g.drawImage(offScreenImage, 0, 0, null);// 把图片画在窗口上  
  135. //      //    drawTank();  
  136. //  
  137. //   }  
  138.       
  139.       
  140.      /** 
  141.      * 用线程重画，每隔一段时间重画窗体 
  142.      * @author Magci 
  143.      * 
  144.      */  
  145.     public class PaintThread implements Runnable {  
  146.   
  147.         /** 
  148.          * 每隔REFRESH_RATE毫秒重画一次窗体 
  149.          */  
  150.         public void run() {  
  151.             while (true) {  
  152.                 repaint();  
  153.                 try {  
  154.                     Thread.sleep(REFRESH_RATE);  
  155.                 } catch (InterruptedException e) {  
  156.                     e.printStackTrace();  
  157.                 }  
  158.             }  
  159.         }  
  160.     }  
  161.       
  162.     public void keyPressed(KeyEvent e) {  
  163.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_UP){//如果按键为向上键  
  164.             myTank.move(0);//向上  
  165.         }  
  166.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_DOWN){//如果按键为向下键  
  167.             myTank.move(1);   
  168.         }  
  169.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_LEFT){//如果按键为向左键  
  170.             myTank.move(2);   
  171.         }  
  172.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_RIGHT){//如果按键为向右键  
  173.             myTank.move(3);  
  174.         }if(e.getKeyCode()==java.awt.event.KeyEvent.VK_SPACE){  
  175.             myTank.fire(g);  
  176.         }  
  177.         //drawTank();  
  178.     }  
  179.   
  180.   
  181.     public void keyReleased(KeyEvent e) {  
  182.     }  
  183.   
  184.   
  185.     public void keyTyped(KeyEvent e) {  
  186.     }  
  187.   
  188. }  

 

 

能是能画出一个坦克，但是闪得你受不了，

 

其主要的原因是，要了解paint闪烁的原因

  每一个paint的过后，程序会自行的调用repaint的方法，但是repaint方法中的绘制有的分配一个与原来窗口一样的的内存空间，但里面是没有存储东西的，所以一次次的paint,repaint的交替就会产生闪烁

 

解决方法：双缓冲技术的工作原理：先在内存中分配一个和窗口一样大的空间（在内存中的空间我门是看不到的），然后利用getGraphics()方法去获得该空间并将它全部一次性的显示到屏幕上．这样显示出来就非常的流畅了．避免了闪烁效果．

Java代码   收藏代码
  1. package My4;  
  2. import java.awt.*;  
  3. import java.awt.event.*;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. public class TankClient extends Frame implements java.awt.event.KeyListener{  
  8.   
  9.     public static final int WINDOW_WIDTH = 800;  
  10.     public static final int WINDOW_HEIGHT = 600;  
  11.     //窗体刷新率  
  12.     public static final int REFRESH_RATE = 50;  
  13.     Image offScreenImage = null;  
  14.     //屏幕画布  
  15.     static java.awt.Graphics g = null;  
  16.     //玩家坦克  
  17.     static Tank myTank = null;  
  18.     // 坦克起始位置左上角坐标  
  19.     public static final int Tank_X = 385;  
  20.     public static final int Tank_Y = 550;  
  21.     //敌方坦克同时出现的最大数量  
  22.     private int tankMaxNum = 10;  
  23.     //当前敌方坦克数量  
  24.     private int tankNum = 0;  
  25.     //存放敌方坦克的容器  
  26.     static List<Tank> enemyTanks = new ArrayList<Tank>();  
  27.     //存放墙的容器  
  28.     static List<Wall> wallList = new ArrayList<Wall>();  
  29.     static int wallNum=35;  
  30.     //草容器  
  31.     static List<Grass> grassList = new ArrayList<Grass>();  
  32.     //方块容器  
  33.     static List<Stone> stoneList = new ArrayList<Stone>();  
  34.       
  35.     static boolean GameBegin=false;  
  36.       
  37.     public static void main(String[] args) {  
  38.   
  39.         // 创建一个窗体  
  40.         TankClient main =new TankClient();  
  41.         main.showUI();  
  42.         main.addKeyListener(main);  
  43.     }  
  44.   
  45.     public void showUI() {  
  46.         this.setTitle("我打坦克大战");  
  47.         this.setBounds(200, 100, WINDOW_WIDTH, WINDOW_HEIGHT);  
  48.         this.setResizable(false);  
  49.         this.setBackground(Color.GREEN);  
  50.         this.addWindowListener(new WindowAdapter() {  
  51.             public void windowClosing(WindowEvent e) {  
  52.                 setVisible(false);  
  53.                 System.exit(0);  
  54.             }  
  55.         });  
  56.         this.setVisible(true);  
  57.         g=this.getGraphics();  
  58.   
  59.     }  
  60.   
  61.       
  62.       
  63.     public void Init(){  
  64.         if(GameBegin==false){  
  65.             return;  
  66.         }  
  67.         //加入我方坦克  
  68.         myTank = new Tank(Tank_X,Tank_Y,true,0);  
  69.         myTank.draw(g);  
  70.         //清空各种容器  
  71.         enemyTanks.clear();  
  72.         wallList.clear();  
  73.         grassList.clear();  
  74.         stoneList.clear();  
  75.         //加入敌方坦克  
  76.         for (int i = 0; i < tankMaxNum; i++) {  
  77.             Tank enemyTank = new Tank(200 + 50 * i, 50, false, 1);  
  78.             enemyTanks.add(enemyTank);  
  79.             enemyTanks.get(i).Go();  
  80.             tankNum++;  
  81.         }  
  82.           
  83.         //加入城墙  
  84.         for (int i=0;i<10;i++){  
  85.             Wall wall = new Wall(100+i*18,100);  
  86.             wallList.add(wall);  
  87.             wall = new Wall(100+i*18,118);  
  88.             wallList.add(wall);  
  89.         }  
  90.         for (int i=0;i<16;i++){  
  91.             Wall wall = new Wall(450+i*18,100);  
  92.             wallList.add(wall);  
  93.             wall = new Wall(450+i*18,118);  
  94.             wallList.add(wall);  
  95.         }  
  96.         for (int i=1;i<=13;i++){  
  97.             Wall wall = new Wall(450+18*7,100+i*18);  
  98.             wallList.add(wall);  
  99.             wall = new Wall(450+18*8,100+i*18);  
  100.             wallList.add(wall);  
  101.         }  
  102.         for (int i=1;i<=2;i++){  
  103.             Wall wall = new Wall(100-18*i,136);  
  104.             wallList.add(wall);  
  105.             wall = new Wall(100-18*i,154);  
  106.             wallList.add(wall);  
  107.         }  
  108.         for (int i=1;i<=2;i++){  
  109.             Wall wall = new Wall(100-18*i,172);  
  110.             wallList.add(wall);  
  111.             wall = new Wall(100-18*i,180);  
  112.             wallList.add(wall);  
  113.         }  
  114.         for (int i=0;i<8;i++){  
  115.             Wall wall = new Wall(100+i*18,198);  
  116.             wallList.add(wall);  
  117.             wall = new Wall(100+i*18,216);  
  118.             wallList.add(wall);  
  119.         }  
  120.         for (int i=8;i<=9;i++){  
  121.             Wall wall = new Wall(100+18*i,234);  
  122.             wallList.add(wall);  
  123.             wall = new Wall(100+18*i,252);  
  124.             wallList.add(wall);  
  125.         }  
  126.         for (int i=8;i<=9;i++){  
  127.             Wall wall = new Wall(100+18*i,270);  
  128.             wallList.add(wall);  
  129.             wall = new Wall(100+18*i,288);  
  130.             wallList.add(wall);  
  131.         }  
  132.         for (int i=-2;i<8;i++){  
  133.             Wall wall = new Wall(100+i*18,306);  
  134.             wallList.add(wall);  
  135.             wall = new Wall(100+i*18,324);  
  136.             wallList.add(wall);  
  137.         }  
  138.   
  139.         for (int i=-2;i<35;i++){  
  140.             Wall wall = new Wall(100+i*18,400);  
  141.             wallList.add(wall);  
  142.             wall = new Wall(100+i*18,418);  
  143.             wallList.add(wall);  
  144.         }  
  145.         //画草  
  146.         for (int i=1;i<=13;i++){  
  147.             Grass grass = new Grass(250+18*7,100+i*18);  
  148.             grassList.add(grass);  
  149.             grass = new Grass(250+18*8,100+i*18);  
  150.             grassList.add(grass);  
  151.         }  
  152.         for (int i=1;i<=13;i++){  
  153.             Grass grass = new Grass(250+18*5,100+i*18);  
  154.             grassList.add(grass);  
  155.             grass = new Grass(250+18*6,100+i*18);  
  156.             grassList.add(grass);  
  157.         }  
  158.         //画出石头  
  159.         for (int i=-2;i<35;i++){  
  160.             Stone stone = new Stone(100+i*18,382);  
  161.             stoneList.add(stone);  
  162.             stone = new Stone(100+i*18,364);  
  163.             stoneList.add(stone);  
  164.         }  
  165.           
  166.          // 启动重画线程  
  167.         PaintThread pt = new PaintThread();  
  168.         Thread t = new Thread(pt);  
  169.         t.start();  
  170.     }  
  171.     /** 
  172.      * 绘制方法 
  173.      */  
  174.     public void paint(Graphics g) {  
  175.         g.setColor(Color.BLACK);//设置黑色背景  
  176.         g.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);  
  177.         if(GameBegin==false){//游戏开始提示标语  
  178.             g.setColor(Color.WHITE);  
  179.             g.drawString("请按F1开始游戏", 100, 100);  
  180.         }  
  181.           
  182.           
  183.         if(myTank==null) return ;  
  184.         myTank.draw(g);  
  185.               
  186.         myTank.draw(g);  
  187.         for (int i=0;i<enemyTanks.size();i++){  
  188.             enemyTanks.get(i).draw(g);  
  189.         }  
  190.         //画出城墙  
  191.         for (int i=0;i<wallList.size();i++){  
  192.             wallList.get(i).draw(g);  
  193.         }  
  194.         //画出草地  
  195.         for (int i=0;i<grassList.size();i++){  
  196.             grassList.get(i).draw(g);  
  197.         }  
  198.         //画出钢快  
  199.         for (int i=0;i<stoneList.size();i++){  
  200.             stoneList.get(i).draw(g);  
  201.         }  
  202.     }  
  203.   
  204.       
  205.       
  206.     // 重写update方法,先将窗体上的图形画在图片对象上，再一次性显示  
  207.     public void update(Graphics g) {  
  208.         if (offScreenImage == null) {  
  209.             offScreenImage = this.createImage(WINDOW_WIDTH, WINDOW_HEIGHT);  
  210.         }  
  211.         Graphics gImage = offScreenImage.getGraphics();  
  212.         Color c = gImage.getColor();  
  213.         gImage.setColor(Color.GREEN);  
  214.         gImage.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);  
  215.         gImage.setColor(c);  
  216.         paint(gImage);  
  217.         g.drawImage(offScreenImage, 0, 0, null);  
  218.     }  
  219.   
  220.     // 用线程重画，每隔一段时间重画窗体  
  221.     private class PaintThread implements Runnable {  
  222.   
  223.         public void run() {  
  224.             while (true) {  
  225.                 repaint();  
  226.                 try {  
  227.                     Thread.sleep(REFRESH_RATE);  
  228.                 } catch (InterruptedException e) {  
  229.                     e.printStackTrace();  
  230.                 }  
  231.             }  
  232.         }  
  233.     }  
  234.   
  235.   
  236.     public void keyPressed(KeyEvent e) {  
  237.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_UP){//如果按键为向上键  
  238.             myTank.move(0);//向上  
  239.         }  
  240.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_DOWN){//如果按键为向下键  
  241.             myTank.move(1);   
  242.         }  
  243.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_LEFT){//如果按键为向左键  
  244.             myTank.move(2);   
  245.         }  
  246.         if(e.getKeyCode()==java.awt.event.KeyEvent.VK_RIGHT){//如果按键为向右键  
  247.             myTank.move(3);  
  248.         }if(e.getKeyCode()==java.awt.event.KeyEvent.VK_SPACE){  
  249.             myTank.fire();  
  250.         }if(e.getKeyCode()==java.awt.event.KeyEvent.VK_F1){//游戏开始  
  251.             GameBegin=true;  
  252.             Init();  
  253.         }  
  254.         //drawTank();  
  255.     }  
  256.   
  257.   
  258.     public void keyReleased(KeyEvent e) {  
  259.     }  
  260.   
  261.   
  262.     public void keyTyped(KeyEvent e) {  
  263.     }  
  264. }  

 

 

就不会再次闪烁了~

主要就是重写了update方法，制定了其刷新的方式~

 

原理：
　１.建立一个Image对象DbBuffer，通过DbBuffer=createrImage(int width,int height)来在内存中开辟一个长为width　宽为heithr空间．次空间的大小可以和你动画窗口的大小保持一致，也可以利用getwidth()和getheight()来获得动画窗口的大小．
　２.建立一个Graphics 对象GraImage通过GraImage=DbBuffer.getGraphics();去把要绘制的对象并存放到分配好的内存空间中．
　３.利用paint(GraImage);将其全部绘制带内存之中，最后调用我门的paint(Graphics g)方法中的g.drawImage(DbBuffer,0,0,null)将DbBuffer全部一次性的绘制到我门的动画窗口，然后把我门内存中分配的空间窗口关闭调用dispose()方法．

Java代码   收藏代码
  1. // 重写update方法,先将窗体上的图形画在图片对象上，再一次性显示  
  2.     public void update(Graphics g) {  
  3.         if (offScreenImage == null) {  
  4.             offScreenImage = this.createImage(WINDOW_WIDTH, WINDOW_HEIGHT);  
  5.         }  
  6.         Graphics gImage = offScreenImage.getGraphics();  
  7.         Color c = gImage.getColor();  
  8.         gImage.setColor(Color.GREEN);  
  9.         gImage.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);  
  10.         gImage.setColor(c);  
  11.         paint(gImage);  
  12.         g.drawImage(offScreenImage, 0, 0, null);  
  13.     }  

无心流泪
关注
专栏目录
java双缓冲技术————包含实例及技术详解，适合新手
10-03
java Applet做动画时总是出现动画闪烁，用双缓冲技术可以解决，献给跟我一样的初学者。
双缓冲在Java编程中的应用
kjfcpua的专栏
03-22 1781
Java的强大特性让其在游戏编程和多媒体动画处理方面也毫不逊色。在Java游戏编程和动画编程中最常见的就是对于屏幕闪烁的处理。本文从J2SE的一个再现了屏幕闪烁的Java Appilication简单动画实例展开，对屏幕闪烁的原因进行了分析，找出了闪烁成因的关键：update(Graphics g)函数对于前端屏幕的清屏。由此引出消除闪烁的方法——双缓冲。双缓冲是计算机动
Java 双缓冲机制
Canon_M的博客
05-25 1284
图形的移动的时候不时会出现闪烁的现象，这是由于在同一个绘图表面上对图形进行反复绘制并擦除所导致的。举例来说，一个绘制的小球，图形的绘制总是在Panle组件的Graphics对象上进行的，在绘制一幅小球的图形后马上更新小球坐标，接着调用repaint()方法擦除已有图形并绘制一幅新的图形。这一过程反复地、快速地进行着，于是就容易产生图形闪烁的现象。可以通过双缓冲机制解决这一问题。双缓冲机制是借助两个...
java中双缓冲_在Java中实现双缓冲
weixin_35261385的博客
02-25 212
我有一个简单的Java JFrame画布.我每半秒左右更新屏幕上的内容,并且闪烁.我想实现双缓冲以消除闪烁,但我对Java很新,并且不熟悉如何这样做.我找到了一些例子,但不知道如何将他们的方法实现到我的.以下是我现在如何处理的基本设置.这不是我的确切代码 – 只是基本设置的一个示例.感谢任何正确方向的推动！public class myCanvas extends Canvas{//variabl...
Java双缓冲技术原理详细讲解例子Java实用源码整理learns
08-31
Java双缓冲技术是一种图形渲染优化策略，主要用于提高GUI（图形用户界面）的性能和减少屏幕闪烁，提升用户体验。在Java中，它主要应用于Swing和JavaFX等图形库。本教程将深入探讨Java双缓冲技术的原理，并通过实例...
Java双缓冲技术原理详细讲解例子
09-13
`paintComponent()`方法的调用顺序至关重要，`super.paintComponent(g)`会开启Swing的默认双缓冲机制。 双缓冲不仅可以应用于Swing组件，还可以用于游戏开发或者其他需要频繁更新图形的场景。通过使用双缓冲，我们...
JAVA人物动画.rar_JAVA画人像_java人物动画_动漫人物java_双缓冲
最新发布
09-20
在这个名为"JAVA人物动画.rar"的压缩包中，我们重点探讨的是如何利用Java来实现生动的人物动画，特别是针对"java画人像"、"java人物动画"、"动漫人物java"和"双缓冲"这些标签所涉及的技术。 首先，让我们深入理解...
java用applet画图用到的方法(涉及双缓冲)
08-25
在Java Applet中，双缓冲通过创建一个额外的图像（`bufImage`）并在其中绘制所有内容来实现。当所有的绘制操作完成后，这个缓冲图像一次性地绘制到屏幕（`g.drawImage(bufImage, 0, 0, null)`），这样可以避免频繁的...
JAVA双缓冲绘图源码
01-30
此外，Java Swing提供了更好的绘图组件JComponent，它的 paintComponent 方法已经内置了双缓冲机制，所以如果你使用Swing，无需手动实现双缓冲，只需重写`paintComponent(Graphics g)`方法进行绘图即可。 通过以上...
Java双缓冲技术详细讲解
09-13
Java双缓冲技术详细讲解，适合初学者，简单易懂，代码
java画图（双缓冲）
05-01
独立写出来的，使用双缓冲，很巧妙的一个方法，实现了画图板的操作，值得模仿。
Java图像处理的双缓存技术演示
05-29
Web应用中的图像处理是非常重要的，Java使用Applet扩展了<img>标签，让程序要可程序控制图像的显示，这给实际开B/S应用带来多一种图像技术，该例子演示了图像处理的双缓存技术处理图像抖动的问题。双缓存技术是Java完成图像应用、游戏应用等必须掌握的技术。
［Java］双缓冲技术
hzylyl2402的专栏
03-25 246
我们很多用Java中的g.drawImage()方法导入图像时，如果我们将当前窗口转变成非当前窗口状态，再从非当前窗口恢复到当前窗口状态，有时，某些绘制好的图像会消失，除非我们重新刷新窗口，显示才会恢复正常。此外，当我们移动窗口或者其他的窗口在上移动的时候，图像会有些闪烁。这是怎么一回事呢？这就要涉及到Canvas中的paint方法的绘图机制了。产生这种现象的主要原因是： 1、由于在显示所绘制的...
JAVA双缓存机制
lilie008的专栏
08-05 1935
我们很多用Java中的g.drawImage()方法导入图像时，如果我们将当前窗口转变成非当前窗口状态，再从非当前窗口恢复到当前窗口状态，有时，某些绘制好的图像会消失，除非我们重新刷新窗口，显示才会恢复正常。此外，当我们移动窗口或者其他的窗口在上移动的时候，图像会有些闪烁。这是怎么一回事呢？这就要涉及到Canvas中的paint方法的绘图机制了。产生这种现象的主要原因是： 1、由于在显示所绘
JAVA中的双缓冲问题
Phoenix Nirvana
03-28 3922
/** *//** *双缓冲 *什么是重量级，轻量级 *轻量级在这里指用纯java实现的。重量级指和其他语言混合编程，这样耗用的资源多系统触发的绘画操作 *绘画操作的分类 *系统触发的和程序触发的绘画操作 *AWT的绘制与界面更新使用了一个单独的线程，称为AWT线程。这个线程可以在两种情形下更新显示。 *一种情况是界面“显露”，这可能会发生在界面首次显示时，或者界面某一部分由于被其它窗口遮盖后
java双缓冲
sk_Overlord_knife的博客
03-20 555
import java.awt.Color; import java.awt.Frame; import java.awt.Graphics; import java.awt.Image; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent;     public class TankClie
双缓存java_Java中的双缓存技术
weixin_28836875的博客
02-12 643
已经停滞在双缓存显示图片这一段时间了，因为代码运行出现了意外，一直想寻求解决的办法，最终找到的方法让我对这个技术颇感到失望。首先描述下问题，先看下面一段代码：//双缓存应用import java.applet.Applet;import java.awt.*;import java.awt.Graphics;import java.awt.Image;public class Media exte...
java双缓存机制_Java双缓冲机制--如何肃清坦克大战中景色的闪烁和白条
weixin_29207533的博客
02-13 219
个人经验，写下来会加深自己的记忆，同时看看自己的日志还能够温习一下，也和大家同时分享！大家都懂得，JavaSE不比JavaME.ME中曾经内置利用了双缓冲的机制(局部旧式手机不扶持),而JavaSE中的双缓冲机制则要自己来告终。做过Java桌面游戏的人可能会觉察，万一无须双缓冲，在许多时候会揭示白色画面一闪而过，这即便因为图像正在描摹而没描摹完，却提前揭示在窗口内构成的。处理这种情形就必需利用双缓...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值