Simple Snake clone in Java

Question

I made a Snake clone for a programming class. I wanted some feedback regarding coding style and will appreciate any other opinions concerning my code.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Snake extends JFrame {

    /* Some properties. */
    private final int BOARD_WIDTH = 20 * 30; // Tilesize * number of columns
    private final int BOARD_HEIGHT = 20 * 30;
    private final int TILE_SIZE = 20;
    private final int ALL_TILES = 900; // Total numer of tiles
    private final int DELAY = 100;

    /* The coordinates of the snake. */
    private int[] xCoor = new int[ALL_TILES];
    private int[] yCoor = new int[ALL_TILES];

    /* Coordinates for apple. */
    private int apple_x, apple_y;

    /* Pressed Key. */
    int pressedKey = KeyEvent.VK_DOWN;
    int oldPressedKey;
    private int snakeSize = 3;
    private boolean inGame = true;


    public class Board extends JPanel implements KeyListener, ActionListener {
    Board(){
        setBackground(Color.black);

        // Set snake starting coordinates. 
        for(int i = 0; i < snakeSize; i++){
          yCoor[i] = 140 - (i * 30);
          xCoor[i] = 140;
        }

        spawnAppleCoor();
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        if (inGame) {

        /* Draw apple. */
        g.setColor(Color.red);
        g.fillRect(apple_x, apple_y, TILE_SIZE, TILE_SIZE);

        /* Draw snake. */
        for (int i = 0; i < snakeSize; i++) {

            if (i == 0) { 
              g.setColor(Color.yellow); // Snakes head yellow
            } else {
              g.setColor(Color.green);}

            g.fillRect(xCoor[i], yCoor[i], TILE_SIZE, TILE_SIZE);
        }

        /* Draw score */
        g.setFont(new Font("Sans serif", Font.BOLD, 20));
        g.drawString(getScore(), 550, 30);

        } else {
          gameOver(g);
        }
    }

    public void actionPerformed(ActionEvent e) {

        checkTile();
        moveSnakeCoor();
        repaint();

    }

    /* Saves pressedKeyCode to pressedKey. */
    public void keyPressed(KeyEvent e) {
        oldPressedKey = pressedKey;
        pressedKey = e.getKeyCode();
    }

    public void keyReleased(KeyEvent e){}
    public void keyTyped(KeyEvent e){}

    private void checkTile(){
        /* Check if outside of wall. */
        if ( xCoor[0] > BOARD_WIDTH || xCoor[0] < 0 || yCoor[0] > BOARD_HEIGHT || yCoor[0] < 0 ) {
             inGame = false;
           }

        /* Check for collisions. */
        for(int i = 1; i < xCoor.length; i++){
          if (xCoor[0] == xCoor[i] && yCoor[0] == yCoor[i]){
              inGame = false;
          }
        }

        /* Check for apples. */
        if ((xCoor[0] == apple_x) && (yCoor[0] == apple_y)) {
          snakeSize++;
          spawnAppleCoor();
        }
    }

    /** Generates random coordinates for apple. */
    private void spawnAppleCoor() {
        int r = (int) (Math.random() * Math.sqrt(ALL_TILES) - 1);
        apple_x = ((r * TILE_SIZE));

        r = (int) (Math.random() * Math.sqrt(ALL_TILES) - 1);
        apple_y = ((r * TILE_SIZE));
    }

    /** Simply prints a gameOver-message to screen when called. */
    private void gameOver(Graphics g) {
        g.setColor(Color.white);
        g.setFont(new Font("Sans serif", Font.BOLD, 20));
        g.drawString(("Game Over! You ate " + (getScore()) + " apples!"),
             BOARD_WIDTH / 4, BOARD_HEIGHT / 2);
        g.drawString("Press space to restart",
             BOARD_WIDTH / 4 + 20, BOARD_HEIGHT / 2 + 30);

        /* Restart game if space is pressed. */
        if (pressedKey == KeyEvent.VK_SPACE){
          inGame = true;
          pressedKey = KeyEvent.VK_DOWN;
          setVisible(false); 
          dispose(); 
          Snake s = new Snake();
        }
    }

    private void moveSnakeCoor(){

        /* Move coordinates up one in the matrix.*/
        for (int i = snakeSize; i > 0; i--) {
          xCoor[i] = xCoor[(i - 1)];
          yCoor[i] = yCoor[(i - 1)];
        }

        /* Depending on what key was pressed, change coordinates
         * accordingly. */
        switch (pressedKey) {
        case KeyEvent.VK_DOWN:
          yCoor[0] += TILE_SIZE;
          break;
        case KeyEvent.VK_UP:
          yCoor[0] -= TILE_SIZE;
          break;
        case KeyEvent.VK_LEFT:
          xCoor[0] -= TILE_SIZE;
          break;
        case KeyEvent.VK_RIGHT:
          xCoor[0] += TILE_SIZE;
          break;
        }
    }

    private String getScore(){
        return "" + (snakeSize - 3);
    }
  }

  public Snake(){
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(BOARD_WIDTH, BOARD_HEIGHT);
    setResizable(false);
    setLocation(50, 50);

    Board b = new Board();
    addKeyListener(b);
    add(b);
    setVisible(true);

    Timer t = new Timer(DELAY, b);
    t.start();
  }

  public static void main (String[] args) {
    Snake s = new Snake();
  }      
}

Answer 1

Pros

• almost consistent Naming following the Java Naming Guideline
• constants instead of "magic numbers"

cons

Code srtucture

• constructor Snake() is last method, should be the first.

inheritance

• Main class extends JFrame instead of just using it. (it does not add new behavior to JFrame, just configures it.)
• class Board implements Listeners directly. Listeners should be implemented as anonymous inner classes or (if bigger) as top level classes of their own.

comments

• almost all comment repeat what the code already does. Comments should explain why the code is like it is. otherwise chose better names considering a comment.
• incheckTile() the comments separate the method into logical blocks. This logical blocks should be methods of their own with names derived from the comments

data structures

• Coordinates of snake elements are stored in two primitive arrays for x and y separately. You constantly must copy these arrays synchronously when changing the snakes position and/or length. Keeping them in a list of custom Coordinate objects could simplify this.

Naming

• still some "magic numbers" left in