Canvas 我的像素赢了'；不要在我画的地方画；我把它们放进去了

我试图使用缓冲策略将单个像素绘制到屏幕上，但当我运行程序时，所有像素都显示为werid，它应该在左上角生成一个正方形，但它会生成多个正方形，它们之间有黑线

显示类

import java.awt.Canvas;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;

import javax.swing.JFrame;

import graphics.Render;

public class Display extends Canvas implements Runnable {

public static final int HEIGHT = 600;
public static final int WIDTH = 800;
public static final String TITLE = "Minefront Pre-Alpha 0.01";

private Thread thread;
private Screen screen;
private BufferedImage img;
private Render render;
private int[] pixels;
public boolean running = false;

public Display()
{
    screen = new Screen(WIDTH, HEIGHT);
    img = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
    pixels = ((DataBufferInt)img.getRaster().getDataBuffer()).getData();
}

public void start() {
    if (running)
        return;
    running = true;
    thread = new Thread(this);
    thread.start();

    System.out.println("Working");
}

public void stop() {
    if (!running)
        return;
    running = false;
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
        System.exit(0);
    }
}

public static void main(String args[]) {
    Display game = new Display();
    JFrame frame = new JFrame();
    frame.add(game);
    frame.pack();
    frame.setSize(WIDTH, HEIGHT);
    frame.setTitle(TITLE);
    frame.setLocationRelativeTo(null);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setResizable(false);
    frame.setVisible(true);

    game.start();

}

@Override
public void run() {
    while(running)
    {
        tick();
        render();
    }
}

private void render() {
    BufferStrategy bs = this.getBufferStrategy();
    if(bs == null)
    {
        createBufferStrategy(3);
        return;
    }

    screen.render();

    for (int i = 0; i < WIDTH * HEIGHT; i++) {
        pixels[i] = screen.pixels[i];
    }

    Graphics g = bs.getDrawGraphics();
    g.drawImage(img, 0, 0, WIDTH, HEIGHT, null);
    g.dispose();
    bs.show();
}

private void tick() {

}
}

导入java.awt.Canvas；
导入java.awt.Graphics；
导入java.awt.image.BufferStrategy；
导入java.awt.image.buffereImage；
导入java.awt.image.DataBufferInt；
导入javax.swing.JFrame；
导入图形。渲染；
公共类显示扩展画布实现可运行{
公共静态最终内部高度=600；
公共静态最终整数宽度=800；
公共静态最终字符串TITLE=“Minefront Pre Alpha 0.01”；
私有线程；
私人屏幕；
专用缓冲图像img；
私人渲染；
私有int[]像素；
公共布尔运行=false；
公开展览（）
{
屏幕=新屏幕（宽度、高度）；
img=新的BuffereImage（宽度、高度、BuffereImage.TYPE\u INT\u RGB）；
像素=（（DataBufferInt）img.getRaster（）.getDataBuffer（））.getData（）；
}
公开作废开始（）{
如果（正在运行）
返回；
运行=真；
线程=新线程（此）；
thread.start（）；
系统输出打印（“工作”）；
}
公共停车场（）{
如果（！正在运行）
返回；
运行=错误；
试一试{
thread.join（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
系统出口（0）；
}
}
公共静态void main（字符串参数[]）{
显示游戏=新显示（）；
JFrame=新JFrame（）；
frame.add（游戏）；
frame.pack（）；
框架尺寸（宽度、高度）；
frame.setTitle（标题）；
frame.setLocationRelativeTo（空）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setresizeable（false）；
frame.setVisible（true）；
game.start（）；
}
@凌驾
公开募捐{
（跑步时）
{
勾选（）；
render（）；
}
}
私有void render（）{
BufferStrategy bs=this.getBufferStrategy（）；
如果（bs==null）
{
创新战略（3）；
返回；
}
screen.render（）；
对于（int i=0；i

渲染类

public class Render {
public final int width;
public final int height;
public final int[] pixels;

public Render(int Height, int Width) {
    this.height = Height;
    this.width = Width;
    pixels = new int[Height * Width];
}

public void draw(Render render, int xOffset, int yOffset) {
    for (int y = 0; y < render.height; y++) {
        int ypix = y + yOffset;
        for (int x = 0; x < render.width; x++) {
            int xpix = x + xOffset;

            pixels[xpix + (ypix * width)] = render.pixels[x + (y * render.width)];
        }
    }
}
}

公共类渲染{
公共最终整数宽度；
公共最终内部高度；
公共最终整数[]像素；
公共渲染（整数高度、整数宽度）{
高度=高度；
这个。宽度=宽度；
像素=新整数[高度*宽度]；
}
公共无效绘制（渲染渲染、int-xOffset、int-yOffset）{
对于（int y=0；y

屏幕类

import graphics.Render;

public class Screen extends Render {

public int Size = 150;
public int Color = 0;
public int R = 0;
public int G = 0;
public int B = 0;

private Render test;

public Screen(int Height, int Width) {
    super(Height, Width);
    test = new Render(Size, Size);
    for (int i = 0; i < Size * Size; i++) {
        Color = RGBtoInt(R, G, B);
        test.pixels[i] = Color;
        R++;
        if (i % 100 == 0 || i % 100 == 1 || i % 100 == 2 || i % 100 == 99 || i % 100 == 98) {
            test.pixels[i] = 16777215;
        } else if (i % 25 == 0 || i % 25 == 1 || i % 25 == 2 || i % 25 == 24 || i % 25 == 23) {
            test.pixels[i] = 3328255;
        } else if (R > 255) {
            R = 0;
            G++;
            if (G > 255) {
                G = 0;
                B++;
                if (B > 255) {
                    B = 0;
                }
            }
        }
    }
}

private int RGBtoInt(int R, int G, int B) {
    R = (R << 16) & 0x00FF0000;
    G = (G << 8) & 0x0000FF00;
    B = B & 0x000000FF;

    return 0xFF000000 | R | G | B;
}

public void render() {
    draw(test,0,0);
}

}

导入图形。渲染；
公共类屏幕扩展渲染{
公共整数大小=150；
公共int颜色=0；
公共int R=0；
公共整数G=0；
公共int B=0；
私人渲染测试；
公共屏幕（整数高度、整数宽度）{
超级（高度、宽度）；
测试=新渲染（大小、大小）；
对于（int i=0；i255），则为else{
R=0；
G++；
如果（G>255）{
G=0；
B++；
如果（B>255）{
B=0；
}
}
}
}
}
专用整数RGB点（整数R、整数G、整数B）{
R=（R在使用前清除缓冲区，您可以使用
Graphics#fillRect
填充特定颜色-您确实需要从干净的画布开始，这意味着渲染到
img
可能是个坏主意，相反，创建
img
的新副本并渲染到它为什么
Screen
需要的实例ode>Render

当它从

Render

扩展时？为什么

Render#draw

需要一个

Render

实例，而它只需要更新自身？