You have to design java console application tic tac toe. Your application must use concepts such as arrays, loops, inheritance, constructors, and information hiding. Output must be shown in the form of a report using the console. You must also write unit tests to validate that your code achieves the desired result.
In your solution, make use of as many concepts and components dealt with in this course, but pay special attention to the following learning units:
• Learning Unit 1: Advanced arrays
• Learning Unit 2: Introduction to Inheritance
in java
Sure! Here's an example of a console-based Tic Tac Toe game written in Java using concepts such as arrays, loops, inheritance, constructors, and information hiding:
```java
import java.util.Arrays;
import java.util.Scanner;
class Player {
private final String name;
private final char symbol;
public Player(String name, char symbol) {
this.name = name;
this.symbol = symbol;
}
public String getName() {
return name;
}
public char getSymbol() {
return symbol;
}
}
class GameBoard {
private final char[][] board;
private int movesLeft;
public GameBoard() {
board = new char[3][3];
movesLeft = 9;
for (char[] row : board) {
Arrays.fill(row, ' ');
}
}
public boolean makeMove(Player player, int row, int col) {
if (row < 0 || row >= 3 || col < 0 || col >= 3 || board[row][col] != ' ') {
return false;
}
board[row][col] = player.getSymbol();
movesLeft--;
return true;
}
public boolean isGameOver() {
return movesLeft == 0 || getWinner() != null;
}
public Player getWinner() {
for (int i = 0; i < 3; i++) {
if (board[i][0] != ' ' && board[i][0] == board[i][1] && board[i][0] == board[i][2]) {
return getPlayerFromSymbol(board[i][0]);
}
if (board[0][i] != ' ' && board[0][i] == board[1][i] && board[0][i] == board[2][i]) {
return getPlayerFromSymbol(board[0][i]);
}
}
if (board[0][0] != ' ' && board[0][0] == board[1][1] && board[0][0] == board[2][2]) {
return getPlayerFromSymbol(board[0][0]);
}
if (board[0][2] != ' ' && board[0][2] == board[1][1] && board[0][2] == board[2][0]) {
return getPlayerFromSymbol(board[0][2]);
}
return null;
}
private Player getPlayerFromSymbol(char symbol) {
if (symbol == 'X') {
return new Player("Player 1", symbol);
} else if (symbol == 'O') {
return new Player("Player 2", symbol);
} else {
return null;
}
}
public void printBoard() {
for (char[] row : board) {
System.out.println(Arrays.toString(row));
}
System.out.println();
}
}
public class TicTacToe {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Player player1 = new Player("Player 1", 'X');
Player player2 = new Player("Player 2", 'O');
GameBoard board = new GameBoard();
Player currentPlayer = player1;
while (!board.isGameOver()) {
System.out.println(currentPlayer.getName() + "'s turn");
board.printBoard();
int row, col;
do {
System.out.print("Enter row (0-2): ");
row = scanner.nextInt();
System.out.print("Enter column (0-2): ");
col = scanner.nextInt();
} while (!board.makeMove(currentPlayer, row, col));
currentPlayer = (currentPlayer == player1) ? player2 : player1;
}
Player winner = board.getWinner();
if (winner != null) {
System.out.println("Congratulations, " + winner.getName() + " wins!");
} else {
System.out.println("It's a draw!");
}
board.printBoard();
}
}
```
To validate that the code achieves the desired result, we can write some unit tests using a testing framework like JUnit:
```java
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class TicTacToeTest {
private GameBoard board;
@BeforeEach
void setup() {
board = new GameBoard();
}
@Test
void testMakeMove() {
Player player1 = new Player("Player 1", 'X');
Player player2 = new Player("Player 2", 'O');
Assertions.assertTrue(board.makeMove(player1, 0, 0));
Assertions.assertTrue(board.makeMove(player2, 1, 1));
Assertions.assertFalse(board.makeMove(player1, 0, 0)); // Already occupied
Assertions.assertFalse(board.makeMove(player2, 1, 1)); // Already occupied
Assertions.assertTrue(board.makeMove(player1, 0, 1));
char[][] expectedBoard = {
{'X', ' ', ' '},
{' ', 'O', ' '},
{' ', ' ', ' '}
};
Assertions.assertArrayEquals(expectedBoard, board.getBoard());
}
@Test
void testIsGameOver() {
Player player1 = new Player("Player 1", 'X');
Player player2 = new Player("Player 2", 'O');
Assertions.assertFalse(board.isGameOver());
// Winning move: vertical line
board.makeMove(player1, 0, 0);
board.makeMove(player2, 1, 1);
board.makeMove(player1, 1, 0);
board.makeMove(player2, 2, 2);
board.makeMove(player1, 2, 0);
Assertions.assertTrue(board.isGameOver());
Assertions.assertEquals(player1, board.getWinner());
}
@Test
void testGetWinner() {
Player player1 = new Player("Player 1", 'X');
Player player2 = new Player("Player 2", 'O');
// Winning move: diagonal line
board.makeMove(player1, 0, 0);
board.makeMove(player2, 1, 1);
board.makeMove(player1, 1, 0);
board.makeMove(player2, 2, 2);
board.makeMove(player1, 2, 0);
Assertions.assertEquals(player1, board.getWinner());
}
}
```
You can run these tests using a testing framework like JUnit to ensure that the code is functioning correctly.
Sure! Let's break down the steps to design the Tic Tac Toe console application in Java using the concepts you mentioned:
Step 1: Create a Board class
- Create a class named "Board" which will represent the Tic Tac Toe game board.
- Use a two-dimensional array to store the state of the game board.
- Provide methods to initialize the board, display the board, and update the board with player moves.
Step 2: Create a Player class
- Create a class named "Player" which will represent the Tic Tac Toe players.
- Use instance variables to store the player's name and symbol (X or O).
- Provide a constructor to initialize the player's name and symbol.
Step 3: Create a Game class
- Create a class named "Game" to manage the game flow and logic.
- Use instance variables to store the Board object and two Player objects.
- Use a loop to alternate between the players for their moves until the game is won or tied.
- Use methods to validate user inputs, check for a win or tie conditions, and display the winner or tie message.
Step 4: Implement inheritance
- Create a parent class named "Player" with common properties like name and symbol.
- Create child classes named "HumanPlayer" and "ComputerPlayer" inheriting from the parent class.
- Implement specific behavior for each child class, such as human input or computer-generated moves.
Step 5: Use information hiding
- Encapsulate the class attributes by making them private and provide public methods to access and modify them (getters and setters).
Step 6: Write unit tests
- Create a separate test class to test the methods and functionality of your classes.
- Write test methods to verify that the board is initialized correctly, player moves are registered, win conditions are checked accurately, and tie conditions are handled correctly.
Once you have implemented these steps, you will have a console application that allows two players to play Tic Tac Toe. The game will display a report-like output in the console and will validate the moves according to the game rules.
Sure! I can help you design a Java console application for Tic Tac Toe using concepts such as arrays, loops, inheritance, constructors, and information hiding. Here's a step-by-step guide on how to approach this task:
Step 1: Set up the project
Create a new Java project in your preferred IDE or text editor.
Step 2: Design the classes
- Create a class called `Game` that represents the Tic Tac Toe game. This class will contain methods to play, validate moves, and check for a win.
- Create a class called `Player`, which represents a player in the game. This class will have properties like name, symbol ('X' or 'O'), and methods to make moves.
- Create a class called `Board` which represents the game board. This class will have a 2D array to store the current state of the board, methods to display the board, and check for a win condition.
Step 3: Implement the classes
- In the `Game` class, implement methods to play the game, switch turns between players, validate moves, and check for a win condition.
- In the `Player` class, create constructors to set the player's name and symbol, and implement methods to make moves.
- In the `Board` class, create a 2D array to store the state of the board, and implement methods to display the board, update the board after each move, and check for a win condition.
Step 4: Write unit tests
- Write unit tests for the methods in the `Game`, `Player`, and `Board` classes to validate that they behave as expected. Test cases should cover all possible scenarios, such as winning conditions, invalid moves, and game draws.
Step 5: Display output as a report
- To display the output of the game as a report, use console output statements to show the board, player's moves, and the final result.
- You can also consider formatting the output using ASCII characters to represent the game board visually.
Step 6: Run the game
- Create an instance of the `Game` class in the main method and call the necessary methods to start the game.
That's it! By following these steps, you can design a Java console application for Tic Tac Toe that incorporates the concepts and components you mentioned, along with unit tests to validate the desired outcomes. Good luck with your project!