与缓冲图像

Question

的Java双缓冲搜索了一天后，我已经放弃了，决定问这个问题：我似乎无法阻止这一计划的不断闪烁：

import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.geom.AffineTransform; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 

import javax.imageio.ImageIO; 

public class Paint { 

    BufferedImage image0, image1, image2; 
    double rotation0 = 0.0001; 
    double rotation1 = 0.0501; 
    double rotation2 = 3.0001; 

    double add0 = 0.0001; 
    double add1 = 0.0016; 
    double add2 = 0.000001; 


    private int x() { 
     return Main.getX()/2; 
    } 

    private int y() { 
     return Main.getY()/2; 
    } 

    public Paint() { 
     try { 
      image0 = ImageIO.read(new File("circle1.jpg")); 
      image1 = ImageIO.read(new File("circle2.jpg")); 
      image2 = ImageIO.read(new File("circle3.jpg")); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    public void paint(Graphics g) { 
     // create the transform, note that the transformations happen 
     // in reversed order (so check them backwards) 
     AffineTransform at0 = new AffineTransform(); 
     AffineTransform at1 = new AffineTransform(); 
     AffineTransform at2 = new AffineTransform(); 

     // 4. translate it to the center of the component 
     at0.translate(x(), y() + 10); 
     at1.translate(x(), y() + 10); 
     at2.translate(x(), y() + 10); 

     // 3. do the actual rotation 
     rotation0 += add0; 
     rotation1 += add1; 
     rotation2 += add2; 
     at0.rotate(rotation0); 
     at1.rotate(rotation1); 
     at2.rotate(rotation2); 

     // 2. just a scale because this image is big 
     at0.scale(1, 1); 
     at1.scale(1, 1); 
     at2.scale(1, 1); 

     // 1. translate the object so that you rotate it around the 
     // center (easier :)) 
     at0.translate(-image0.getWidth()/2, -image0.getHeight()/2); 
     at1.translate(-image1.getWidth()/2, -image1.getHeight()/2); 
     at2.translate(-image2.getWidth()/2, -image2.getHeight()/2); 

     // draw the image 
     Graphics2D g2d = (Graphics2D) g; 
     g2d.drawImage(image0, at0, null); 
     g2d.drawImage(image1, at1, null); 
     g2d.drawImage(image2, at2, null); 
    } 
} 

重要：一切工作，但双缓冲，这会导致图像闪烁。如果您不介意，请提供代码和答案。

Answer 1

双缓冲包括将您的内容绘制到内部图像，然后在屏幕上绘制该图像。通过这样做，图像从未被部分打印。

因此，不要直接在Graphics对象中绘制3个图像，而是将它们绘制到新的BufferedImage中，然后在Graphics对象（屏幕）中绘制该图像。

更多信息请参阅本官方网页：https://docs.oracle.com/javase/tutorial/extra/fullscreen/doublebuf.html

Answer 2

我假设的用法是在一个JPanel孩子。默认情况下，JPanel是双缓冲的。

JPanel panel new JPanel() { 
    Paint paint = new Paint(); 

    @Override 
    public void paintComponent(Graphics g) { 
     paint.paint(g); 
    } 
}; 
.. add the panel to the JFrame. 

这应该在Java 摆动工作。 Java awt组件是另一个陈旧的的问题。