Class asking for unimplemented methods for inherited abstract

Question

I have these 3 classes which is supposed to work together to create a game. But I'm getting an error in one of them where it wants me to add unimplemented methods. The class which is creating the error is called Game and looks like this.

package org.game.main;

import java.awt.Graphics2D;

public class Game extends Window {
    public static void main(String[] args) {
        Window window = new Game();
        window.run(1.0 / 60.0);
        System.exit(0);
    }

    public Game() {
        // call game constructor
        super("Test Game", 640, 480);
    }

    public void gameStartup() {

    }

    public void gameUpdate(double delta) {

    }

    public void gameDraw(Graphics2D g) {

    }

    public void gameShutdown() {

    }
}

It wants me to implement the method called Update() from the Window class. The Window class looks like this.

package org.game.main;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics2D;
import java.awt.image.BufferStrategy;
import org.game.input.*;

/**
 * Game that creates a window and handles input.
 * @author Eric
 */
public abstract class Window extends GameLoop {
    private Frame frame;
    private Canvas canvas;
    private BufferStrategy buffer;
    private Keyboard keyboard;
    private Mouse mouse;
    private MouseWheel mouseWheel;

    /**
     * Creates a new game window.
     *
     * @param title title of the window.
     * @param width width of the window.
     * @param height height of the window.
     */
    public Window(String title, int width, int height) {
        /*Log.debug("Game", "Creating game " +
                title + " (" + width + ", " + height + ")");*/

        // create frame and canvas
        frame = new Frame(title);
        frame.setResizable(false);
        canvas = new Canvas();
        canvas.setIgnoreRepaint(true);
        frame.add(canvas);
        // resize canvas and make the window visible
        canvas.setSize(width, height);
        frame.pack();
        frame.setVisible(true);

        // create buffer strategy
        canvas.createBufferStrategy(2);
        buffer = canvas.getBufferStrategy();

        // create our input classess and add them to the canvas
        keyboard = new Keyboard();
        mouse = new Mouse();
        mouseWheel = new MouseWheel();
        canvas.addKeyListener(keyboard);
        canvas.addMouseListener(mouse);
        canvas.addMouseMotionListener(mouse);
        canvas.addMouseWheelListener(mouseWheel);
        canvas.requestFocus();
    }

    /**
     * Get the width of the window.
     *
     * @return the width of the window.
     */
    public int getWidth()
    {
        return canvas.getWidth();
    }

    /**
     * Get the height of the window.
     *
     * @return the height of the window.
     */
    public int getHeight()
    {
        return canvas.getHeight();
    }

    /**
     * Returns the title of the window.
     *
     * @return the title of the window.
     */
    public String getTitle()
    {
        return frame.getTitle();
    }

    /**
     * Returns the keyboard input manager.
     * @return the keyboard.
     */
    public Keyboard getKeyboard()
    {
        return keyboard;
    }

    /**
     * Returns the mouse input manager.
     * @return the mouse.
     */
    public Mouse getMouse()
    {
        return mouse;
    }

    /**
     * Returns the mouse wheel input manager.
     * @return the mouse wheel.
     */
    public MouseWheel getMouseWheel() {
        return mouseWheel;
    }

    /**
     * Calls gameStartup()
     */
    public void startup() {
        gameStartup();
    }

    /**
     * Updates the input classes then calls gameUpdate(double).
     * @param delta time difference between the last two updates.
     */
    public void update(double delta) {
        // call the input updates first
        keyboard.update();
        mouse.update();
        mouseWheel.update();
        // call the abstract update
        gameUpdate(delta);
    }

    /**
     * Calls gameDraw(Graphics2D) using the current Graphics2D.
     */
    public void draw() {
        // get the current graphics object
        Graphics2D g = (Graphics2D)buffer.getDrawGraphics();
        // clear the window
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
        // send the graphics object to gameDraw() for our main drawing
        gameDraw(g);
        // show our changes on the canvas
        buffer.show();
        // release the graphics resources
        g.dispose();
    }

    /**
     * Calls gameShutdown()
     */
    public void shutdown() {
        gameShutdown();
    }

    public abstract void gameStartup();
    public abstract void gameUpdate(double delta);
    public abstract void gameDraw(Graphics2D g);
    public abstract void gameShutdown();
}

The last class is called Gameloop and looks like this.

package org.game.main;

public abstract class GameLoop {
    private boolean runFlag = false;

    /**
     * Begin the game loop
     * @param delta time between logic updates (in seconds)
     */
    public void run (double delta) {
        runFlag = true;

        startup();
        // convert the time to seconds
        double nextTime = (double) System.nanoTime() / 1000000000.0;
        double maxTimeDiff = 0.5;
        int skippedFrames = 1;
        int maxSkippedFrames = 5;
        while (runFlag) {
            // convert the time to seconds
            double currTime = (double) System.nanoTime() / 1000000000.0;
            if ((currTime - nextTime) > maxTimeDiff) nextTime = currTime;
            if (currTime >= nextTime) {
                // assign the time for the next update
                nextTime += delta;
                update();
                if ((currTime < nextTime) || (skippedFrames > maxSkippedFrames)) {
                    draw();
                    skippedFrames = 1;
                }
                else {
                    skippedFrames++;
                }
            } else {
                // calculate the time to sleep
                int sleepTime = (int)(1000.0 * (nextTime - currTime));
                // sanity check
                if (sleepTime > 0) {
                    // sleep until the next update
                    try {
                        Thread.sleep(sleepTime);
                    }
                    catch(InterruptedException e) {
                        // do nothing
                    }
                }
            }
        }
        shutdown();
    }

    public void stop() {
        runFlag = false;
    }

    public abstract void startup();
    public abstract void shutdown();
    public abstract void update();
    public abstract void draw();
}

The error I'm getting in console when I run the main class looks like this.

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The type Game must implement the inherited abstract method GameLoop.update()

    at org.game.main.Game.update(Game.java:5)
    at org.game.main.GameLoop.run(GameLoop.java:26)
    at org.game.main.Game.main(Game.java:8)

I hope you can help me. I'm quite new to java.

Answer 1

Okay i found it out with some of the help that you suggested. It was because I hadn't defined Update() in GameLoop as.

public abstract void update(double delta);

Insted of

public abstract void update();

So the method didn't get called in Window. So then it had to be called in Game. Thanks for the help, everything works as should now.

Answer 2

You have implement unimplemented methods of Game Window and GameLoop class

Implement abstract methods. Window class' abstract methods are following:

public abstract void gameStartup();
public abstract void gameUpdate(double delta);
public abstract void gameDraw(Graphics2D g);
public abstract void gameShutdown();

Also implement following methods of GameLoop class

public abstract void startup();
public abstract void shutdown();
public abstract void update();
public abstract void draw();

Answer 3

In GameLoop you have defined

public abstract void update();

This method must be implemented in one of the sub classes Window or Game with the same signature.

Answer 4

The signature of the update method is not overriding the interface, if that's what you intended.

public void update(double delta)

You need it to match the interface

public abstract void update();

So it sounds like this simple change should help:

public abstract void update(double delta);