Java 空指针异常，尽管操作正确

我最近正在编写代码，但遇到了空指针异常 堆栈跟踪显示

Exception in thread "main" java.lang.NullPointerException
at com.masterkgames.twisteddream.level.SpawnLevel.generateLevel(SpawnLevel.java:34)
at com.masterkgames.twisteddream.level.Level.<init>(Level.java:22)
at com.masterkgames.twisteddream.level.SpawnLevel.<init>(SpawnLevel.java:16)
at com.masterkgames.twisteddream.Game.<init>(Game.java:49)
at com.masterkgames.twisteddream.Game.main(Game.java:138)

线程“main”java.lang.NullPointerException中的异常 位于com.masterkgames.twistedStream.level.SpawnLevel.generateLevel（SpawnLevel.java:34） 位于com.masterkgames.twistedStream.level.level.（level.java:22） 位于com.masterkgames.twistedStream.level.SpawnLevel。（SpawnLevel.java:16） 在com.masterkgames.twistedStream.Game上。（Game.java:49） 位于com.masterkgames.twistedStream.Game.main（Game.java:138） 下面是提到的3个类

prownlevel.java： 包com.masterkgames.twistedStream.level

import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

import com.masterkgames.twisteddream.level.tile.Tile;

public class SpawnLevel extends Level {

private Tile[] tiles;
private int[] levelPixels;

public SpawnLevel(String path) {
    super(path);

}

protected void loadLevel(String path){
    try{
        BufferedImage image = ImageIO.read(SpawnLevel.class.getResource(path));
        int w = image.getWidth();
        int h = image.getHeight();
        tiles = new Tile[w * h];
        levelPixels = new int[w * h];
        image.getRGB(0,0,w,h,levelPixels,0,w);
    }catch(IOException e){
        e.printStackTrace();
    }

}
protected void generateLevel(){
        for(int i = 0; i < levelPixels.length; i++){
            if(levelPixels[i] == 0xff00) tiles[i] = Tile.Grass;
            if(levelPixels[i] == 0xffff00) tiles[i] = Tile.Rose;
            if(levelPixels[i] == 0x7f7f00) tiles[i] = Tile.Stone;
        }
    }
}

导入java.awt.image.buffereImage；
导入java.io.IOException；
导入javax.imageio.imageio；
导入com.masterkgames.twistedStream.level.tile.tile；
公共类级别扩展级别{
私人瓷砖[]瓷砖；
私有整数像素；
公共级别（字符串路径）{
超级（路径）；
}
受保护的无效加载级别（字符串路径）{
试一试{
BuffereImage image=ImageIO.read（SpawnLevel.class.getResource（path））；
int w=image.getWidth（）；
int h=image.getHeight（）；
瓷砖=新瓷砖[w*h]；
levelPixels=新整数[w*h]；
getRGB（0,0，w，h，levelPixels，0，w）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
受保护的void generateLevel（）{
对于（int i=0；i

level.java：

package com.masterkgames.twisteddream.level;

import com.masterkgames.twisteddream.graphics.Screen;
import com.masterkgames.twisteddream.level.tile.Tile;

public class Level {

public Screen screen;
protected int width, height;
protected Tile[] tiles;
protected int[] tilesInt;

public Level(int width, int height) {
    this.width = width;
    this.height = height;
    tilesInt = new int[width * height];
    generateLevel();
}

public Level(String path) {
    loadLevel(path);
    generateLevel();
}

protected void generateLevel() {

}

private void loadLevel(String path) {

}

public void update() {

}

private void time() {

}

public void render(int xScroll, int yScroll, Screen screen) {
    screen.setOffset(xScroll, yScroll);
    int x0 = xScroll >> 4;
    int x1 = (xScroll + screen.width + 16) >> 4;
    int y0 = yScroll >> 4;
    int y1 = (yScroll + screen.height + 16) >> 4;

    for (int y = y0; y < y1; y++) {
        for (int x = x0; x < x1; x++) {
            // getTile(x, y).render(x, y, screen);
            if (x + y * 16 < 0 || x + y * 16 >= 256) {
                Tile.Void.render(x, y, screen);
                continue;
            }
            tiles[x + y * 16].render(x, y, screen);

        }
    }
}

public Tile getTile(int x, int y) {
    if (x < 0 || y < 0)
        return Tile.Void;
    if (x >= width || y >= height)
        return Tile.Void;
    if (tilesInt[x + y * width] == 0)
        return Tile.Grass;
    if (tilesInt[x + y * width] == 1)
        return Tile.Rose;
    if (tilesInt[x + y * width] == 2)
        return Tile.Stone;

    return Tile.Void;
}

}

package com.masterkgames.twistedStream.level；
导入com.masterkgames.twistedStream.graphics.Screen；
导入com.masterkgames.twistedStream.level.tile.tile；
公营班级{
公共屏幕；
保护内部宽度、高度；
受保护瓷砖[]瓷砖；
受保护的int[]tilesInt；
公共级别（整数宽度、整数高度）{
这个。宽度=宽度；
高度=高度；
tilesInt=新整数[宽度*高度]；
generateLevel（）；
}
公共级别（字符串路径）{
负载水平（路径）；
generateLevel（）；
}
受保护的void generateLevel（）{
}
私有void加载级别（字符串路径）{
}
公共无效更新（）{
}
专用空闲时间（）{
}
公共void渲染（int-xScroll、int-yScroll、Screen-Screen）{
screen.setOffset（xScroll、yScroll）；
int x0=xScroll>>4；
intx1=（xScroll+screen.width+16）>>4；
int y0=yScroll>>4；
inty1=（yScroll+screen.height+16）>>4；
对于（int y=y0；y=256）{
瓦片。空白。渲染（x，y，屏幕）；
继续；
}
平铺[x+y*16]。渲染（x，y，屏幕）；
}
}
}
公共磁贴getTile（int x，int y）{
if（x<0 | | y<0）
返回瓷砖。无效；
如果（x>=宽度| | y>=高度）
返回瓷砖。无效；
如果（tilesInt[x+y*宽度]==0）
返回瓦。草；
if（tilesInt[x+y*宽度]==1）
返回瓷砖。玫瑰；
如果（tilesInt[x+y*宽度]==2）
返回瓷砖。石头；
返回瓷砖。无效；
}
}

最后 game.java：

package com.masterkgames.twisteddream;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;

import javax.swing.JFrame;

import com.masterkgames.twisteddream.entity.mob.Player;
import com.masterkgames.twisteddream.graphics.Screen;
import com.masterkgames.twisteddream.input.Keyboard;
import com.masterkgames.twisteddream.level.Level;
import com.masterkgames.twisteddream.level.SpawnLevel;

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

public static int width = 300;
public static int height = 168;
public static int scale = 3;

public String Title = "Twisted Dream";

private Thread thread;

private boolean running = false;

private Screen screen;
private Keyboard key;
private Level level;
private Player player;

private JFrame frame;
private BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

private int[] pixels = ((DataBufferInt)image.getRaster().getDataBuffer()).getData();

public Game() {
    Dimension size = new Dimension(width * scale, height * scale);
    setPreferredSize(size);

    screen = new Screen(width,height);
    key = new Keyboard();
    level = new SpawnLevel("/textures/level.png");
    player = new Player(key);

    frame = new JFrame();

    addKeyListener(key);
}

public synchronized void start() {
    thread = new Thread(this, "Display");
    thread.start();
    running = true;
}

public synchronized void stop() {
    running = false;
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void run() {
    long lastTime = System.nanoTime();
    long timer = System.currentTimeMillis();
    final double ns = 1000000000.0 / 60.0;
    double delta = 0; 
    int frames = 0;
    int updates = 0;
    requestFocus();
    while (running) {
        long nowTime = System.nanoTime();
        delta += (nowTime - lastTime) / ns;
        lastTime = nowTime;
        while (delta >= 1){
        update();
        updates++;
        delta--;

        }
        render();
        frames++;

        if(System.currentTimeMillis() - timer > 1000){
            timer += 1000;
            System.out.println(updates + " ups, " + frames + " fps");
            frame.setTitle(Title + "  |  " + updates + " ups, " + frames + " fps");
            updates = 0;
            frames = 0;
        }
    }
    stop();
}

public void update() {
    key.update();
    player.update();
}

public void render() {
    BufferStrategy bs = getBufferStrategy();

    if (bs == null) {
        createBufferStrategy(3);
        return;
    }


    screen.clear();
    int xScroll = player.x - screen.width / 2;
    int yScroll = player.y - screen.height / 2;
    level.render(xScroll, yScroll, screen);
    player.render(screen);


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

    Graphics g = bs.getDrawGraphics();
    g.drawImage(image,0,0,getWidth(),getHeight(),null);
    g.setFont(new Font("arial", 0, 15));
    g.setColor(Color.white);
    g.dispose();
    bs.show();
}

public static void main(String[] args) {
    Game game = new Game();

    game.frame.setResizable(false);
    game.frame.setTitle(game.Title);
    game.frame.add(game);
    game.frame.pack();
    game.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    game.frame.setLocationRelativeTo(null);
    game.frame.setVisible(true);

    game.start();
}

}

package com.masterkgames.twistedStream；
导入java.awt.Canvas；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Font；
导入java.awt.Graphics；
导入java.awt.image.BufferStrategy；
导入java.awt.image.buffereImage；
导入java.awt.image.DataBufferInt；
导入javax.swing.JFrame；
导入com.masterkgames.twistedStream.entity.mob.Player；
导入com.masterkgames.twistedStream.graphics.Screen；
导入com.masterkgames.twistedStream.input.Keyboard；
导入com.masterkgames.twistedStream.level.level；
导入com.masterkgames.twistedStream.level.SpawnLevel；
公共类游戏扩展画布实现可运行{
私有静态最终长serialVersionUID=1L；
公共静态整数宽度=300；
公共静态内部高度=168；
公共静态int标度=3；
公共字符串Title=“扭曲的梦想”；
私有线程；
私有布尔运行=false；
私人屏幕；
私钥；
私人层面；
私人玩家；
私有JFrame；
私有BuffereImage=新的BuffereImage（宽度、高度、BuffereImage.TYPE_INT_RGB）；
私有int[]像素=（（DataBufferInt）image.getRaster（）.getDataBuffer（））.getData（）；
公共游戏（）{
尺寸尺寸=新尺寸（宽度*比例，高度*比例）；
设置首选大小（大小）；
屏幕=新屏幕（宽度、高度）；
键=新键盘（）；
级别=新级别（“/textures/level.png”）；
玩家=新玩家（键）；
frame=新的JFrame（）；
addKeyListener（键）；
}
公共同步的void start（）{
线程=新线程（此“显示”）；
thread.start（）；
运行=真；
}
公共同步无效停止（）{
运行=错误；
试一试{
thread.join（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
公开募捐{
long lastTime=System.nanoTime（）；
长定时器=System.currentTimeMillis（）；
最终双ns=100000000.0/60.0；
双增量=0；
int帧=0；
int=0；
requestFocus（）；
（跑步时）{
long nowTime=System.nanoTime（）；
增量+=（nowTime-lastTime）/ns；
lastTime=nowTime；
而（增量>=1）{
更新（）；
更新++；
三角洲--；
}
render（）；
frames++；
if（System.currentTimeMillis（）-计时器>1000）{
定时器+=1000；
System.out.println（更新+“ups”+“帧+“fps”）；
frame.setTitle（Title+“|”+更新+“ups”+“frames+“fps”）；
更新=0；
帧=0；
}
}
停止（）；
}
公共无效更新（）{
key.update（）；
player.update（）；
}
公共无效呈现（）{
BufferStrategy bs=getBufferStrategy（）；
如果（bs==null）{
创造
private void loadLevel(String path) {

}