“隐式超级构造函数 Block() 未定义" [英] "Implicit super constructor Block() is undefined"

问题描述

我正在创建一个游戏.当我扩展 Block 类时，它显示一个错误.

I'm creating a game. When I'm extending my Block class it shows an error.

错误:隐式超级构造函数 Block() 未定义.必须显式调用另一个构造函数

Error: Implicit super constructor Block() is undefined. Must explicitly invoke another constructor

代码:

Game.java:

package lt.projecturanium;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferStrategy;
import java.util.HashMap;

import javax.swing.JFrame;

import lt.projecturanium.blocks.Block;
import lt.projecturanium.blocks.BlockRectangle;
import lt.projecturanium.entity.Player;
@SuppressWarnings("unused")

public class Game extends Canvas implements Runnable{

    private static final long serialVersionUID = 1L;

    private static JFrame _frame;
    public static Game _instance;

    private static final String TITLE = "Project Uranium";
    private static final int WIDTH = 650;
    private static final int HEIGHT = WIDTH * 3 / 4;

    private static final int UPDATE_RATE = 50;
    private static final int RENDER_RATE = 100;

    public static HashMap<Block, Coordinates> blocks = new HashMap<Block, Coordinates>();

    public int rectx = 0;
    public int recty = 0;
    public int rectID = 0;

    public boolean hitted = false;

    public float interpolation;

    public static final Dimension SIZE = new Dimension(WIDTH, HEIGHT);

    private Thread _thread;

    private boolean _running;

    private int _totalTicks = 0;
    private int _tps = 0;
    private int _fps = 0;

    public Game()
    {
        _instance = this;
        setPreferredSize(SIZE);
        setMinimumSize(SIZE);
        setMaximumSize(SIZE);

        _frame = new JFrame(TITLE);

        _frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        _frame.setLayout(new BorderLayout());
        _frame.add(_instance, BorderLayout.CENTER);
        _frame.pack();

        _frame.setResizable(false);
        _frame.setLocationRelativeTo(null);
        _frame.setVisible(true);
        createBufferStrategy(2);
        blocks.put(new Block(new BlockRectangle(200)), new Coordinates(30, 50));
    }
    public synchronized void start()
    {
        _running = true;
        _thread = new Thread(this, TITLE+"_main");
        _thread.start();
    }
    public synchronized void stop()
    {
        _running = false;
        if (_thread != null)
        {
            try {
                _thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void paint(Graphics g) {
        super.paint(g);  // fixes the immediate problem.
        Graphics2D g2 = (Graphics2D) g;
        g2.drawString("FPS: " + _fps + "\n TPS: " + _tps, 10, 10);
        if (hitted)
        {
            recty = 0;
            rectx += 21;
            rectID++;
            blocks.put(new Block(new BlockRectangle(rectID)), new Coordinates(rectx, recty));
            hitted = false;
        }
        recty++;
        g2.drawImage(Player.getTexture(), 60, 60, null);
        g2.drawRect(rectx, recty, 20, 20);
        g2.setColor(new Color(101, 67, 33));
        g2.fillRect(0, 430, getWidth(), getHeight());
        g2.setColor(new Color(0, 100, 0));
        g2.fillRect(0, 420, getWidth(), 10);
        g2.setColor(Color.BLACK);
        if (recty == (419 - 20))
        {   
            hitted = true;
        }
    }
    public void run() {
        double lastUpdateTime = System.nanoTime();
        double lastRenderTime = lastUpdateTime;
        final int ns = 1000000000;
        final double nsPerUpdate = (double) ns / UPDATE_RATE;
        final double nsPerRender = (double) ns / RENDER_RATE;
        final int maxUpdatesBeforeRender = 5;

        int lastSecond = (int) (lastUpdateTime / ns);
        int tickCount = 0;
        int renderCount = 0;
        while (_running) {

          long currTime = System.nanoTime();
          int tps = 0;

          while ((currTime - lastUpdateTime) > nsPerUpdate && tps < maxUpdatesBeforeRender) {
            update();
            tickCount++;
            _totalTicks++;
            tps++;
            lastUpdateTime += nsPerUpdate;
            interpolation = Math.min(1.0F, (float) ((currTime - lastUpdateTime) / nsPerUpdate));
            render(interpolation, getGraphics());
          }

          if (currTime - lastUpdateTime > nsPerUpdate) {
            lastUpdateTime = currTime - nsPerUpdate;
          }
          if (currTime - lastRenderTime == maxUpdatesBeforeRender + 1)
          {
              render(interpolation, getGraphics());
          }
          renderCount++;
          lastRenderTime = currTime;

          int currSecond = (int) (lastUpdateTime / ns);
          if (currSecond > lastSecond) {
            _tps = tickCount;
            _fps = renderCount;
            tickCount = 0;
            renderCount = 0;
            lastSecond = currSecond;
            _frame.setTitle(TITLE + " | TPS: " + _tps + " | FPS: "+ _fps);

          }

          while (currTime - lastRenderTime < nsPerRender && currTime - lastUpdateTime < nsPerUpdate) {
            Thread.yield();
            try {
              Thread.sleep(1);
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
            currTime = System.nanoTime();
          }
        }   
      }
    public void update()
    {
        _frame.pack();
    }
    public void render(float interp, Graphics g)
    {
        BufferStrategy myStrategy = getBufferStrategy(); 
        Graphics gra = myStrategy.getDrawGraphics();
        paint(gra);
        g.dispose();
        myStrategy.show();
        //System.out.println("Grass x: " + blocks.get("grass").getX() + " y: " + blocks.get("grass").getY());
        System.out.println("Stone x: " + blocks.get(new Block(new BlockRectangle(rectID))).getX() + " y: " + blocks.get(new Block(new BlockRectangle(rectID))).getY());
    }
}

Block.java:

Block.java:

package lt.projecturanium.blocks;

public class Block {
    private Block block;
    public Block (Block block){
        this.block = this;
    }
    public Block getBlock() {
        return block;
    }
    public Block getBlockById(int id)
    {
        return block;
    }
}

BlockRectangle.java:

BlockRectangle.java:

package lt.projecturanium.blocks;

import java.awt.Image;
import java.io.IOException;
import java.util.HashMap;

import javax.imageio.ImageIO;

import lt.projecturanium.Game;

public class BlockRectangle extends Block{
    private int id;
    private static HashMap<Integer, BlockRectangle> rects = new HashMap<Integer, BlockRectangle>();
    public BlockRectangle(int id)
    {
        this.id = id;
    }
    public int getID()
    {
        return this.id;
    }
    public static BlockRectangle getByID(int id)
    {
        return rects.get(id);
    }
    public static Image getTexture()
    {
        try{        
            return ImageIO.read(Game._instance.getClass().getClassLoader().getResource("../res/player.png"));   
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        return null;
    }
}

坐标.java:

package lt.projecturanium;

public class Coordinates {
    private int x;
    private int y;
    public Coordinates(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
    public int getX()
    {
        return this.x;
    }
    public int getY()
    {
        return this.y;
    }
}

推荐答案

public class BlockRectangle extends Block

BlockRectangle 扩展 Block.所以在BlockRectangle的构造函数中，你必须首先通过super()调用Block的构造函数.

BlockRectangle extends Block. So in the constructor of BlockRectangle, you must at first call a constructor of Block via super().

public BlockRectangle(int id){
    //This line is optional if Block has an empty constructor.
    super([...]);
    this.id = id;
}

如果 Block 有一个空的构造函数，它将被隐式调用.事实并非如此.因此，您必须自己显式调用 super()(或定义一个空的构造函数).

If Block had an empty constructor, it would have been implicitly called. That's not the case. Hence, you must exmplicitly call super() yourself (or define an empty constructor).

注意 :如果 Block 根本没有构造函数，则会隐式创建一个空的构造函数.

Note : If Block had no constructor at all, an empty constructor would have been implicitly created.

这篇关于“隐式超级构造函数 Block() 未定义"的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！