I am getting an error message help please

Error: Main method not found in class Minesweeper, please define the main method as: public static void main(String[] args) or a JavaFX application class must extend javafx.application.Application

import java.util.HashSet; import java.util.Random;

/** * minesweeper class provides the data * and methods for a minesweper game * * Level 1 - data & methods to implement * Mines, Clues, Tiles, basic Board characters, * and opening/marking tiles *

* Level 2 - Additional data & methods to support game status * and extended Board characters *

* minesweeper.java * spring 2004 * */ public class Minesweeper {

/** * mine and clue values, 9 - mine, 0-8 clue values * */ public int[][] mines;

/** * tile values 0 - open, 1 - closed, * 2 - question, 3 - mine */ public int[][] tiles;

/** * Level 2 - game status win, lose, play */ private String status;

/** * default constructor * board size 9 x 9 * create mines and tile arrays * place mines * calculate clues * (*)set game status to play */

public Minesweeper() { initGame(9, 9); }

/** * alternate constructor use specifies board size * create mines and tile arrays * place mines * calculate clues * (*)set game status to play * * @param newRows * number of rows for grid * @param newCols * number of columns for grid */ public Minesweeper(int newRows, int newCols) { initGame(newRows, newCols); }

/** * Level 2 - game status * * @return "play", "win", or "lose" */ public String getStatus() { return status; }

/** * number of rows for board * * @return number of rows */ public int getRows() { return mines.length; }

/** * number of columns for board * * @return number of columns */ public int getCols() { return mines[0].length; }

/** * value of the mines array at r,c * -1 is returned if invalid r,c * * @param r * row index * @param c * column index * @return value of mines array, -1 if invalid */ public int getMines(int r, int c) { if (validIndex(r, c)) { return mines[r][c]; } else { return -1; } }

/** * value of the tiles array at r,c -1 is returned if invalid r,c * * @param r * row index * @param c * column index * @return value of tiles array, -1 if invalid */ public int getTiles(int r, int c) { if (validIndex(r, c)) { return tiles[r][c]; } else { return -1; } }

/** * mark tile - open tile, close tile, * flag tile as mine, set tile as question mark, close tile * * Level 1 - Requirements * - invalid r,c values must be ignored * - a tile that is opened must stay open * - a tile that is marked as a flag (ie. tile[][] value 3) can not be * opened * * Level 2 - Requirements * - tile values can only change when game status is "play" * - game status must be updated after a tile is opened * * * @param r * row index * @param c * column index * @param t * 0 - open, 1 - close, 2 - question, 3 - mine */ public void markTile(int r, int c, int t) { if (validIndex(r, c)) { if ((tiles[r][c] == 0) || (t == 0 && tiles[r][c] == 3)) { return; } // no tile can be closed if(t == 1) return; if (!status.equals("play")) { tiles[r][c] = t; // if we try to open a mine if(mines[r][c] == 9 && t==0) { status = "lose"; return; } // recalculate status gameWon(); } } }

/** * mines array as String * * @return mines array as a String */ public String toStringMines() { String result = " "; for (int r = 0; r < mines.length; r++) { for (int c = 0; c < mines[r].length; c++) result = result + mines[r][c]; result += " "; } return result; }

/** * tiles array as String * * @return mines array as a String */ public String toStringTiles() { String result = " "; for (int r = 0; r < mines.length; r++) { for (int c = 0; c < mines[r].length; c++) result = result + tiles[r][c]; result += " "; } return result; }

/** * game board array as String * * @return game board as String */ public String toStringBoard() { String result = ""; for (int r = 0; r < tiles.length; r++) { for (int c = 0; c < tiles[r].length; c++) { result += this.getBoard(r, c); } result += " "; // advance to next line } return result; }

/** * getBoard - determines current game board character for r,c position * using the value of the mines[][] and tiles[][]array * Note: Level 2 values are returned when * game is over (ie. status is "win" or "lose") * * * Level 1 values * '1'-'8' opened tile showing clue value * ' ' opened tile blank * 'X' tile closed * '?' tile closed marked with ? * 'F' tile closed marked with flag * '*' mine * * * Level 2 values * '-' if game lost, mine that was incorrectly flagged * '!' if game lost, mine that ended game * 'F' if game won, all mines returned with F * * @return char representing game board at r,c */ public char getBoard(int r, int c) { if (status.equals("win")) { // level 2 if(mines[r][c] == 9) { return 'F'; } } else if (status.equals("lose")) { // level 2 if(mines[r][c] != 9 && tiles[r][c] == 3) return '-'; if(mines[r][c] != 9 && tiles[r][c] == 0) return '!'; } else { // level 1 if (tiles[r][c] == 0) { if (mines[r][c] == 0) return ' '; else if (mines[r][c] == 9) return '*'; else return numToChar(mines[r][c]); } else if (tiles[r][c] == 1) { return 'X'; } else if (tiles[r][c] == 2) { return '?'; } else { return 'F'; } } return ' '; }

/** * create mines & tiles array place mines * update clues * * @param newRows * number of rows for grid * @param newCols * number of columns for grid */ private void initGame(int newRows, int newCols) { // allocate space for mines and tiles array if ((newRows >= 1) && (newCols >= 1)) { mines = new int[newRows][newCols]; tiles = new int[newRows][newCols]; // init tiles array resetTiles(); // place mines placeMines(); // update clues calculateClues(); // set game status status = "play"; } }

/** * Sets all tiles to 1 - closed */ private void resetTiles() { for (int i = 0; i < tiles.length; i++) { for (int j = 0; j < tiles[i].length; j++) { tiles[i][j] = 1; } } }

/** * places mines randomly on grid integer value 9 represents a mine * number of mines = (1 + number of columns * number rows) / 10 * minimum number of mines = 1 */ private void placeMines() { int n = (1 + tiles.length * tiles[0].length) / 10; HashSet set = getUniqueRandom(n, tiles.length * tiles[0].length); for (Integer i : set) { int r = i / tiles[0].length; int c = i % tiles[0].length;

mines[r][c] = 9; } }

private HashSet getUniqueRandom(int n, int range) { Random r = new Random(); HashSet set = new HashSet<>(); while (set.size() < n) { set.add(r.nextInt(range)); } return set; }

/** * calculates clue values and updates clue values in mines array * integer value 9 represents a mine * clue values will be 0 ... 8 */ private void calculateClues() { for (int i = 0; i < mines.length; i++) { for (int j = 0; j < mines[i].length; j++) { if(mines[i][j] != 9) { int count = 0; if(validIndex(i+1, j + 1) && mines[i+1][j+1] == 9) count++; if(validIndex(i, j + 1) && mines[i][j+1] == 9) count++; if(validIndex(i-1, j + 1) && mines[i-1][j+1] == 9) count++; if(validIndex(i-1, j) && mines[i-1][j] == 9) count++; if(validIndex(i+1, j) && mines[i+1][j] == 9) count++; if(validIndex(i-1, j - 1) && mines[i-1][j-1] == 9) count++; if(validIndex(i, j - 1) && mines[i][j-1] == 9) count++; if(validIndex(i+1, j - 1) && mines[i+1][j-1] == 9) count++; mines[i][j] = count; } } } }

/** * determines if x,y is valid position * * @param x * row index * @param y * column index * @return true if valid position on board, false if not valid board * position */ private boolean validIndex(int x, int y) { if(x < 0 || x>= tiles.length || y<0 || y>= tiles[0].length) return false; return true; }

/** * Level 2 - game won status * * @return true if game won false if game not won */ private boolean gameWon() { int mines = 0; for (int i = 0; i < tiles.length; i++) { for (int j = 0; j < tiles[i].length; j++) { if(tiles[i][j] == 1 || tiles[i][j] == 2) { return false; } if(tiles[i][j] == 3) { mines++; } } } if(mines == (1 + tiles.length * tiles[0].length) / 10) { status = "win"; return true; } else { return false; } }

/* * Given num between 0 and 9, return the character representation of the * number */ private char numToChar(int num) { return (char) ((char) num + '0'); } }