Java 如何解决此数组越界异常？

你好，以氢为基础的生命形式。我在一个绝密网站（www.youtube.com）上学习如何制作三维gaems，我在一个非常好的youtube上学习。我的项目如下所示：

有3个类：主类、屏幕类和渲染类 我得到这个例外：（：

我也将在下面上传我的代码。请帮助我变得擅长这个

主要类别：

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;  

public class Main extends Canvas implements Runnable {
private static final long serialVersionUID = 1L;

public static final int WIDTH = 800;
public static final int HEIGHT = 600;
public static final String TITLE = "Nexus Overload";

private Thread t;
private boolean Running = false;

@SuppressWarnings("unused")
private Render ren;
private Screen s;

private BufferedImage img;
private BufferStrategy bs;
private int[] pixels;

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

private void start() {
    if (Running)
        return;
    Running = true;

    t = new Thread(this);
    t.start();
}

@SuppressWarnings("unused")
private void stop() {
    if (!Running)
        return;
    Running = false;
    try {
        t.join();
    } catch (Exception e) {
        e.printStackTrace();
        System.exit(0);
    }
}

public void run() {
    while (Running) {
        tick();
        render();
    }
}

private void tick() {

}

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

    s.render();

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

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

}

public static void main(String[] args) {
    Main m = new Main();

    JFrame frame = new JFrame();
    frame.getContentPane().add(m);
    frame.setResizable(false);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setBounds(350, 100, WIDTH, HEIGHT);
    frame.setTitle(TITLE);
    frame.setVisible(true);

    m.start();
}
}

导入java.awt.Canvas；
导入java.awt.Graphics；
导入java.awt.image.BufferStrategy；
导入java.awt.image.buffereImage；
导入java.awt.image.DataBufferInt；
导入javax.swing.JFrame；
公共类Main扩展画布实现Runnable{
私有静态最终长serialVersionUID=1L；
公共静态最终整数宽度=800；
公共静态最终内部高度=600；
公共静态最终字符串TITLE=“Nexus重载”；
私有线程t；
私有布尔运行=false；
@抑制警告（“未使用”）
私家侦探；
私人屏幕；
专用缓冲图像img；
私人缓冲区；
私有int[]像素；
公用干管（）{
s=新屏幕（宽度、高度）；
img=新的BuffereImage（宽度、高度、BuffereImage.TYPE\u INT\u RGB）；
像素=（（DataBufferInt）img.getRaster（）.getDataBuffer（））.getData（）；
}
私有void start（）{
如果（正在运行）
返回；
运行=真；
t=新螺纹（本螺纹）；
t、 start（）；
}
@抑制警告（“未使用”）
私人停车场（）{
如果（！正在运行）
返回；
运行=错误；
试一试{
t、 join（）；
}捕获（例外e）{
e、 printStackTrace（）；
系统出口（0）；
}
}
公开募捐{
（跑步时）{
勾选（）；
render（）；
}
}
私人空白勾号（）{
}
私有void render（）{
bs=this.getBufferStrategy（）；
如果（bs==null）{
创新战略（3）；
返回；
}
s、 render（）；
对于（int i=0；i

渲染类：

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

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

public void Draw (Render ren, int xOffset, int yOffset) {
    for (int y = 0; y < ren.height; y++) {
        int yPix = y + yOffset;

        for (int x = 0; x < ren.width; x++) {
            int xPix = x + xOffset;

            pixels[xPix + yPix * width] = ren.pixels[xPix + yPix * width];
        }
    }
}
}

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

屏幕类别：

import java.util.Random;

public class Screen extends Render{

private Render ren;

public Screen(int width, int height) {
    super(width, height);

    Random r = new Random();

    ren = new Render(256, 256);
    for (int i = 0; i < 256 * 256; i++) {
        ren.pixels[i] = r.nextInt();
    }
}

public void render() {
    Draw(ren, 0, 0);
}

}

import java.util.Random；
公共类屏幕扩展渲染{
私家侦探；
公共屏幕（整数宽度、整数高度）{
超级（宽度、高度）；
随机r=新随机（）；
ren=新渲染（256，256）；
对于（int i=0；i<256*256；i++）{
ren.pixels[i]=r.nextInt（）；
}
}
公共无效呈现（）{
绘制（任，0，0）；
}
}

对于希望使用eclipse调试映像的用户，请参见： 选择变量选项卡后：

---

您的异常将我们指向Render类中的Draw方法（注意：Java约定方法名称应为小写，因此此方法实际上应称为Draw（Render ren、int xOffset、int yOffset）。我会首先尝试将外部for循环中的int y设置为1，看看这是否有帮助，您可能也会对内部for循环中的int x执行相同的操作…

您的异常将我们指向渲染类中的Draw方法（注意：Java约定方法名称应为小写，因此此方法实际上应称为Draw）（Render ren，int xOffset，int yOffset）。我首先尝试将外部for循环中的int y设置为1，看看这是否有帮助，您也可以对内部for循环中的int x执行相同的操作…

我们不是氢基，我们是碳基：）另外，你不知道如何跟踪堆栈跟踪？在使用调试器后，你的发现是什么？@有些人我现在知道它来自哪里，但我似乎无法解决我想你的意思是：

pixels[xPix+yPix*width]=ren.pixels[x+y*ren.width]

@Phylogenesis youtuber就是这么做的，没有什么不正确的地方，但当我尝试时……我们不是氢基的，我们是碳基的：）而且，你不知道如何跟踪堆栈跟踪？在使用调试器后，你的发现是什么？@有人告诉我它来自哪里，但我似乎无法解决我想你的意思是：

像素[xPix+yPix*width]=ren.像素[x+y*ren.宽度]

@Phylogenesis youtuber会这样做，没有什么不正确的地方，但是当我尝试…在这里评论时，因为我没有足够的代表对OP进行评论-你能用上面在调试视图中选择的变量选项卡拍摄相同的屏幕截图吗？好的，现在就在这里评论，因为我没有足够的代表对OP进行评论-你能拍摄s吗ame屏幕截图，如上所述，在调试视图中选择了变量选项卡？现在确定

import java.util.Random;

public class Screen extends Render{

private Render ren;

public Screen(int width, int height) {
    super(width, height);

    Random r = new Random();

    ren = new Render(256, 256);
    for (int i = 0; i < 256 * 256; i++) {
        ren.pixels[i] = r.nextInt();
    }
}

public void render() {
    Draw(ren, 0, 0);
}

}