调用paint（）方法时图像闪烁

Question

package Game;

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.*;

import Maps.*;

public class Window extends JFrame implements KeyListener
{
    private Insets insets;
    private int currentMapX;
    private int currentMapY;

    public Window()
    {
        super();
        setSize(new Dimension(1920, 1080));
        setLayout(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setUndecorated(true);
        setFocusable(true);
        setContentPane(new Container());
        setBackground(Color.BLACK);
        addKeyListener(this);
    }

    public void startGame()
    {
        insets = getInsets();
        currentMapX = 960 - (Game.level_01.getWidth() / 2); 
        currentMapY = 540 - (Game.level_01.getHeight() / 2);
        Game.level_01.setBounds(currentMapX, currentMapY, Game.level_01.getWidth(), Game.level_01.getHeight());
        add(Game.level_01);
    }

    private void moveMapRight()
    {
        Game.level_01.setBounds(++currentMapX, currentMapY, Game.level_01.getWidth(), Game.level_01.getHeight());
    }

    private void moveMapLeft()
    {
        Game.level_01.setBounds(--currentMapX, currentMapY, Game.level_01.getWidth(), Game.level_01.getHeight());
    }

    public void paint(Graphics g)
    {
        super.paint(g);
        Graphics2D g2d = (Graphics2D)g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        Game.player.paint(g2d);
    }

    public void keyPressed(KeyEvent k) 
    {
        if(k.getKeyCode() == KeyEvent.VK_RIGHT) moveMapRight();
        if(k.getKeyCode() == KeyEvent.VK_LEFT) moveMapLeft();
    }
    public void keyReleased(KeyEvent k){}
    public void keyTyped(KeyEvent k){}
}

我有第一个扩展JFrame的类，其中包含以下类。

package Maps;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.RenderingHints;
import java.io.*;
import java.util.*;

import javax.swing.*;

import Game.*;
import Tiles.*;

public class Level extends JPanel
{
    protected final File txt_MAP;
    protected final ArrayList<Tile> jLabel_MAP;
    protected final ArrayList<Integer> linesLength;
    protected Insets insets = Game.window.getInsets();
    protected int arrayIndex;
    protected int leftIndex;
    protected int topIndex;
    protected int width;
    protected int height;

    public Level(File f)
    {
        super();
        setLayout(null);
        setBackground(Color.BLACK);
        leftIndex = 0;
        topIndex = 0;
        txt_MAP = f;
        jLabel_MAP = new ArrayList<>();
        linesLength = new ArrayList<>();
        arrayIndex = 0;
        readTxt();
        width = linesLength.get(0) * Game.tileSize;
        height = linesLength.size() * Game.tileSize;
        addTiles();
    }

    private void readTxt()
    {
        BufferedReader br = null;
        try
        {
            br = new BufferedReader(new FileReader(txt_MAP));
        }
        catch(FileNotFoundException e){}
        try
        {
            String line = br.readLine();
            while(line != null)
            {
                String[] words = line.split(" ");
                for(int a = 0; a < words.length; a++)
                {
                    for(int b = 0; b < Game.tilesIcons.length; b++)
                    {
                        if(Game.tilesList[b].getName().equals(words[a] + ".gif"))
                        {
                            if(Game.tilesList[b].getName().contains(Game.grass_TYPE)) jLabel_MAP.add(arrayIndex, new Grass(Game.tilesIcons[b]));
                            if(Game.tilesList[b].getName().contains(Game.soil_TYPE)) jLabel_MAP.add(arrayIndex, new Soil(Game.tilesIcons[b]));
                            if(Game.tilesList[b].getName().contains(Game.sky_TYPE)) jLabel_MAP.add(arrayIndex, new Sky(Game.tilesIcons[b]));
                            arrayIndex++;
                        }
                    }
                }
                linesLength.add(words.length);
                line = br.readLine();
            }
        }
        catch(IOException e){}
    }

    private void addTiles()
    {
        for(int i = 0; i < jLabel_MAP.size(); i++)
        {
            jLabel_MAP.get(i).setBorder(null);
            jLabel_MAP.get(i).setBounds(insets.left + leftIndex, insets.top + topIndex, 64, 64);
            add(jLabel_MAP.get(i));
            if(leftIndex == width - Game.tileSize) 
            {
                leftIndex = 0;
                topIndex += 64;
            }
            else leftIndex += 64;
        }
    }

    public int getWidth()
    {
        return width;
    }

    public int getHeight()
    {
        return height;
    }
}

此类扩展JPanel并包含Jlabels的arrayList。

package Player;

import java.awt.*;

import Game.*;

public class Player
{
    private int x;
    private int y;
    private int xa;
    private int ya;
    private Graphics2D g2d; 
    public Player(double x, double y)
    {
        super();
        this.x = (int)x;
        this.y = (int)y;
        xa = 0;
        ya = 1;
    }

    public void movePlayer()
    {
        x += xa;
        y += ya;
    }

    public void setDirection(int xa, int ya)
    {
        this.xa = xa;
        this.ya = ya;   
    }

    public void paint(Graphics g)
    {
        g2d = (Graphics2D)g;
        g2d.drawImage(Game.playerImages[6], x , y, Game.tileSize, Game.tileSize, null);
    }

    public int getX()
    {
        return x;
    }

    public int getY()
    {
        return y;
    }

    public int getXA()
    {
        return xa;
    }

    public int getYA()
    {
        return ya;
    }
}

最后，该类是播放器的类，即BufferedImage。 我的问题是，当我启动程序时，播放器图像开始闪烁，因为当我在JFrame类中调用paint（）方法时，它将先绘制jpanel，然后再绘制播放器图像。 如何解决图像闪烁？ 提前致谢。

Answer 1

就像其他人所说的那样，您不应该在顶级组件中覆盖paint(Graphics g) ，这是问题的一部分，但是您还需要注意确保每次重新绘制仅在屏幕上绘制一次：

我的问题是，当我启动程序时，播放器图像开始闪烁，因为当我在JFrame类中调用paint（）方法时，它将先绘制jpanel，然后再绘制播放器图像。

现在发生的是，每次调用在paint(Graphics screen)方法中修改Graphics对象的方法时，它都是直接修改屏幕内容，从而在完成绘制真正想要的操作之前强制屏幕刷新- Player 。 首先绘画为super ，然后再进行自定义渲染，实际上是在绘画至少两次，从而导致闪烁。 您可以通过双重缓冲解决此问题。

双缓冲涉及首先渲染图像，然后将该图像绘制到屏幕上。 使用Component类提供的内置方法（请记住， JPanel扩展了Component ），您可以获得组件可视区域的大小。 创建一个相同大小的BufferedImage ，然后调用bufferedImage.createGraphics() -这将为您提供一个Graphics2D对象，您可以将其用于绘制到您的bufferedImage上。 完成渲染到bufferedImage ，调用screen.drawImage(bufferedImage,0,0,null) 。 这使您可以根据需要多次修改bufferedImage ，而无需实际刷新屏幕，然后在一次调用中将缓冲区的内容绘制到屏幕上。

附加信息

我应该早先指出，我对您在屏幕上实际布置的方式一无所知，因此您可能需要对播放器屏幕区域的边界以及通话中应将左上方放置的位置进行一些其他检查到drawImage(Image,x,y,ImageObserver) 。 还要注意BufferedImage的透明度或缺乏透明度-如果在屏幕上其他重要内容上绘制不透明像素，则很容易迷失方向。

尝试一下（但不要保留）

同样，我不建议您在顶级组件中进行所有绘画，但是您可以在此期间尝试执行以下操作：

//This is in the Window class:
public void paint(Graphics screen)
{
    //Render everything first to a BufferedImage:
    BufferedImage bufferedImage = ... //Initialize based on Window's
                                      //size and bounds.
    Graphics2D buf = bufferedImage.createGraphics();
    super.paint(buf);
    buf.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
            RenderingHints.VALUE_ANTIALIAS_ON);
    Game.player.paint(buf);

    //Now paint the buffer to screen:
    int x = ... //set to top-left x-coordinate, probably 0
    int y = ... //set to top-left y-coordinate, probably 0
    screen.drawImage(buf,x,y,null);
}

Answer 2

1. 不要在顶级容器（如JFrame paint(Graphics)中重写paint(Graphics) （它不是双缓冲的）。 而是在JPanel （ 具有双缓冲）中进行自定义绘制。
2. 同样，当覆盖任何绘制方法时，请立即调用super方法，从而绘制背景并有效擦除较早的绘制。