Using OpenGL with LWJGL won't yield a picture

Question

Im trying to create and RPG game based on the youtube series from TheBennyBox, and so far I have 8 classes, which are supposed to display a square with openGL and able to move the square around, although my square is not shwoing up on the screen. Here's my code for the important classes: Main:

    package com.base.engine;
    import java.util.logging.Level;
    import java.util.logging.Logger;

    import org.lwjgl.LWJGLException;
    import org.lwjgl.input.Keyboard;
    import org.lwjgl.opengl.Display;
    import org.lwjgl.opengl.DisplayMode;

    import com.base.game.Game;

    import static org.lwjgl.opengl.GL11.*;
    public class Main {
        private static Game game;
    public static void main(String[] args){
        initDisplay();
        initGL();
        initGame();
        gameLoop();
    }
    private static void gameLoop(){
        while(!Display.isCloseRequested()){
            getInput();
            update();
            render();
        }
    }
    private static void initGame(){
        game = new Game();
    }
    private static void render() {
        glClear(GL_COLOR_BUFFER_BIT);
        glLoadIdentity();
        Display.update();
        Display.sync(60);
        game.render();
    }
    private static void update() {
        game.update();

    }
    private static void getInput() {
        game.getInput();

    }
    private static void initGL(){
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0,Display.getWidth(),0,Display.getHeight(),-1,1);
        glMatrixMode(GL_MODELVIEW);
        glDisable(GL_DEPTH_TEST);
        glClearColor(0,0,0,0);
    }
    private static void cleanUp(){
        Display.destroy();
        Keyboard.destroy();
    }

    private static void initDisplay(){
        try {
            Display.setDisplayMode(new DisplayMode(800,600));
            Display.create();
            Keyboard.create();
            Display.setVSyncEnabled(true);
        } catch (LWJGLException ex) {
            // TODO Auto-generated catch block
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE,null,ex);
        }

    }

    }

Game:

    package com.base.game;

    import java.util.ArrayList;

    import org.lwjgl.opengl.Display;

    import com.base.engine.GameObject;
    import com.base.game.gameobject.Player;

    public class Game {
        private ArrayList<GameObject> objects;
        private Player player;
        public Game(){
            objects = new ArrayList<GameObject>();
            player = new Player(Display.getWidth()/2-Player.SIZE/2,Display.getHeight()/2-Player.SIZE/2);
            objects.add(player);
        }

    public void getInput(){
        player.getInput();
    }
    public void update(){
        for(GameObject go : objects){
            go.update();
        }
    }
    public void render(){
        for(GameObject go : objects){
            go.render();
        }
    }

    }

GameObject:

    package com.base.engine;
    import static org.lwjgl.opengl.GL11.*;
    public abstract class GameObject {
    protected float x;
    protected float y;
    protected float sx;
    protected float sy;
    protected Sprite spr;
    public void update(){

    }
    public void render(){
        glPushMatrix();
        {
            glTranslatef(x,y,0);
            spr.render();

        }
        glPopMatrix();
    }
    public float getX() {
        return x;
    }
    public void setX(float x) {
        this.x = x;
    }
    public float getY() {
        return y;
    }
    public void setY(float y) {
        this.y = y;
    }
    public float getSx(){
        return spr.getSx();
    }
    public float getSy(){
        return spr.getSy();
    }
    protected void init(float x,float y,float r, float g, float b, float sx, float sy){
        this.x=x;
        this.y=y;
        this.spr = new Sprite(r,g,b,sx,sy);

    }
    }

Sprite:

    package com.base.engine;
    import static org.lwjgl.opengl.GL11.*;
    public class Sprite {
    private float r;
    private float g;
    private float b;
    private float sx;
    private float sy;
    public Sprite(float r,float g,float b,float sx,float sy){
        this.g=g;
        this.r=r;
        this.b=b;
        this.sx=sx;
        this.sy=sy;

    }
        public void render() {
            glColor3f(r,g,b);
            glBegin(GL_QUADS);
            {
            glVertex2f(0,0);
            glVertex2f(0,sy);
            glVertex2f(sx,sy);
            glVertex2f(sx,0);
            }
            glEnd();

        }
    public float getSx(){
        return sx;
    }
    public float getSy(){
        return sy;
    }
    public void setSx(float sx){
        this.sx = sx;
    }
    public void setSy(float sy){
        this.sy=sy;
    }
    }

Player:

    package com.base.game.gameobject;
    import org.lwjgl.input.Keyboard;

    import com.base.engine.GameObject;
    import com.base.engine.Sprite;
    public class Player extends GameObject{
        public static final float SIZE = 32;

    public Player(float x, float y){
        init(x,y,0.1f,1f,0.25f,SIZE,SIZE);
    }
    public void getInput(){
        if(Keyboard.isKeyDown(Keyboard.KEY_W)){
            move(0,1);
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_S)){
            move(0,-1);
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_A)){
            move(-1,0);
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_D)){
            move(0,1);
        }

    }
    private void move(float magX,float magY){
        x += getSpeed()-magX;
        y += getSpeed()-magY;
    }
    public float getSpeed(){
        return 4f;
    }
    }

And there are others but these are the most important. Sorry for so much code..i just don't know whats going wrong.

Answer 1

I'm not an expert on LWJGL, bit normally you call the sync functions after you rendered. The way it's currently written I presume that you draw the picture after buffer swap (i.e. after contents of the framebuffer were sent to the screen) but the next render iteration will clear it. Try reordering a few things:

private static void render() {
    glClear(GL_COLOR_BUFFER_BIT);
    glLoadIdentity();

    game.render();

    Display.update();
    Display.sync(60);
}

Note that a lot of other things skewed as well. The standard preamble of a frame render iteration is setting up the viewport and the projection. I.e. the whole code in your initGL belongs at the begin of render.