From 2b9b700876ac296d5e9e3fd54e561254df7b7573 Mon Sep 17 00:00:00 2001 From: "John P. Baugh" Date: Wed, 26 Jan 2022 23:42:30 -0500 Subject: [PATCH] Add files via upload --- section6/CountDown.java | 23 ++++ section6/FunWith2DArrays.java | 43 +++++++ section6/MethodCalls.java | 19 +++ section6/MethodOverloading.java | 31 +++++ section6/MethodsDemo.java | 44 +++++++ section6/Proj6_1_SumOfElements.java | 27 ++++ section6/Proj6_2_TicTacToe.java | 190 ++++++++++++++++++++++++++++ 7 files changed, 377 insertions(+) create mode 100644 section6/CountDown.java create mode 100644 section6/FunWith2DArrays.java create mode 100644 section6/MethodCalls.java create mode 100644 section6/MethodOverloading.java create mode 100644 section6/MethodsDemo.java create mode 100644 section6/Proj6_1_SumOfElements.java create mode 100644 section6/Proj6_2_TicTacToe.java diff --git a/section6/CountDown.java b/section6/CountDown.java new file mode 100644 index 0000000..6a6b09f --- /dev/null +++ b/section6/CountDown.java @@ -0,0 +1,23 @@ + +public class CountDown { + public static void main(String[] args) { + //countDownFrom(10); + + countUpTo(0, 10); + }//end main + + public static void countDownFrom(int num) { + if(num >= 0) { + System.out.println(num); + countDownFrom(num - 1); + } + }//end countDownFrom + + public static void countUpTo(int from, int to) { + if(from <= to) { + System.out.println(from); + countUpTo(from + 1, to); + } + }//end countUpTo + +} diff --git a/section6/FunWith2DArrays.java b/section6/FunWith2DArrays.java new file mode 100644 index 0000000..8c07798 --- /dev/null +++ b/section6/FunWith2DArrays.java @@ -0,0 +1,43 @@ +import java.util.Random; + +public class FunWith2DArrays { + public static void main(String[] args) { + //2 row x 3 column + int[][] my2DArray = new int[2][3]; //2 rows x 3 columns + + fill2DArray(my2DArray); + print2DArray(my2DArray); + System.out.println(); + twice2DArray(my2DArray); + print2DArray(my2DArray); + }//end main + + public static void fill2DArray(int[][] twoDArr) { + Random rand = new Random(); + + for(int i = 0; i < twoDArr.length; i++) { + for(int j = 0; j < twoDArr[i].length; j++) { + //randomize 0 through 99 (inclusive) + //row i, column j + twoDArr[i][j] = rand.nextInt(100); //0 ... 99 (inclusive) + } + }//end for i + }//end fill2DArray + + public static void print2DArray(int[][] twoDArr) { + for(int[] arr : twoDArr) { + for(int num : arr) { + System.out.print(num + " "); + }//end of inner for loop + System.out.println(); + } + }//end print2DArray + + public static void twice2DArray(int[][] twoDArr) { + for(int i = 0; i < twoDArr.length; i++) { + for(int j = 0; j < twoDArr[i].length; j++) { + twoDArr[i][j] *= 2; + }//end for j + }//end for i + }//end twice2DArray +} diff --git a/section6/MethodCalls.java b/section6/MethodCalls.java new file mode 100644 index 0000000..9803b0c --- /dev/null +++ b/section6/MethodCalls.java @@ -0,0 +1,19 @@ + + +public class MethodCalls { + public static void main(String[] args) { + doSomething(); + }//end main + + public static void doSomething() { + System.out.println("In doSomething!"); + + int result = getSomeValue(); + + System.out.println("result: " + result); + } + + public static int getSomeValue() { + return 150; + } +} diff --git a/section6/MethodOverloading.java b/section6/MethodOverloading.java new file mode 100644 index 0000000..f2c1dab --- /dev/null +++ b/section6/MethodOverloading.java @@ -0,0 +1,31 @@ + +public class MethodOverloading { + public static void main(String[] args) { + int result = getResult(5); + System.out.println(result); + + result = getResult(5,4); + System.out.println(result); + + result = getResult(5, "12"); + System.out.println(result); + + System.out.println(getResult("John", "Baugh")); + }//end main + + public static int getResult(int num) { + return num * 2; + }//end getResult + + public static int getResult(int num1, int num2) { + return num1 * num2; + }//end getResult + + public static int getResult(int num1, String value) { + return num1 * Integer.parseInt(value); + }//end getResult + + public static String getResult(String str1, String str2) { + return str1 + " " + str2; + } +} diff --git a/section6/MethodsDemo.java b/section6/MethodsDemo.java new file mode 100644 index 0000000..bcd8ff3 --- /dev/null +++ b/section6/MethodsDemo.java @@ -0,0 +1,44 @@ + + +public class MethodsDemo { + public static void main(String[] args) { + printHello(); + printNumber(10); //argument 10 is passed in + int result = giveMe10(); + double dResult; + System.out.println(result); + + result = addThese(3, 5); //arguments 3 and 5 passed in + System.out.println(result); + + dResult = square(5.5); + System.out.println(dResult); + + System.out.println(square(7.25)); + + }//end main + + //void, parameterless + public static void printHello() { + System.out.println("Hello there!"); + }//end printHello + + //void, parameterized + public static void printNumber(int a) { + System.out.println("The number is " + a); + }//end printNumber + + //value-returning, parameterless + public static int giveMe10() { + return 10; + }//end giveMe10 + + //value-returning, parameterized + public static int addThese(int num1, int num2) { + return num1 + num2; + }//end addThese + + public static double square(double num) { + return num * num; + }//end square +} diff --git a/section6/Proj6_1_SumOfElements.java b/section6/Proj6_1_SumOfElements.java new file mode 100644 index 0000000..939c545 --- /dev/null +++ b/section6/Proj6_1_SumOfElements.java @@ -0,0 +1,27 @@ +import java.util.ArrayList; + +public class Proj6_1_SumOfElements { + public static void main(String[] args) { + ArrayList someList = + new ArrayList<>(); + + someList.add(10); + someList.add(22); + someList.add(55); + someList.add(121); + + int sum = sumElements(someList); + + System.out.println("sum is " + sum); + }//end main + + public static int sumElements(ArrayList list) { + int sum = 0; + + for(int i = 0; i < list.size(); i++) { + sum += list.get(i); + }//end for i + + return sum; + }//end sumElements +} diff --git a/section6/Proj6_2_TicTacToe.java b/section6/Proj6_2_TicTacToe.java new file mode 100644 index 0000000..8584cef --- /dev/null +++ b/section6/Proj6_2_TicTacToe.java @@ -0,0 +1,190 @@ + +import java.util.Scanner; + + +public class Proj6_2_TicTacToe { + + public static void main(String[] args) { + runGame(); + }//end main + + public static void runGame() { + String winner = ""; + boolean xTurn = true; + int theRow = 0; + int theCol = 0; + String[][] gameBoard = new String[3][3]; + + initializeGameBoard(gameBoard); + + //print initial board + printCurrentBoard(gameBoard); + + //"" signals no winner + while(winner.equals("")) { + if(xTurn) { + System.out.println("It is X's turn"); + } + else { + System.out.println("It is O's turn"); + } + + getUserInput(xTurn, gameBoard); + System.out.println(); //extra spacing + + printCurrentBoard(gameBoard); //reprint board + winner = getWinner(gameBoard); + xTurn = !xTurn; //flip it! + + if(winner.equals("") && isBoardFull(gameBoard)) { + winner = "C"; + }//end if + }//end while + + //cat's game? + System.out.println(); + + if(winner.equals("C")) { + System.out.println("It was the Cat's game! NO WINNER!"); + } + else { + System.out.println("The winner is " + winner); + }//end if-else + }//end runGame + + public static void initializeGameBoard( + String[][] gameBoard) { + + for(int i = 0; i < gameBoard.length; i++) { + for(int j = 0; j < gameBoard[i].length; j++) { + gameBoard[i][j] = " "; + }//end for j + }//end for i + }//end initializeGameBoard + + public static void printCurrentBoard( + String[][] gameBoard) { + + for(int i = 0; i < gameBoard.length; i++) { + for(int j = 0; j < gameBoard[i].length; j++) { + System.out.print(gameBoard[i][j]); + if(j < 2) { + System.out.print(" | "); + } + //next line + }//end for j + System.out.println(); + if(i < 2) { + System.out.print("- - - - -"); + } + //to add space between the board and next + //output + System.out.println(); + }//end for i + }//end printCurrentBoard + + public static void getUserInput(boolean xTurn, + String[][] gameBoard) { + Scanner keyboard = new Scanner(System.in); + + int row = -1; + int col = -1; + boolean keepAsking = true; + + while(keepAsking) { + System.out.println("Please enter the row THEN " + + "the column, each from 0, 1, or 2, " + + "separated by a space"); + + row = keyboard.nextInt(); + col = keyboard.nextInt(); + keyboard.nextLine(); //consume newline + + //if we are in bounds with row and column + if(row >= 0 && row <= 2 && + col >= 0 && col <= 2) { + //valid and in-range selection + //but, is it occupied by an X or O already? + if(!cellAlreadyOccupied(row, col, gameBoard)) { + keepAsking = false; + } + else { + System.out.println("That cell is already occupied!"); + }//end if-else + }//end if + }//end while + + //by the time it gets here, we know it's a VALID row and column + //in range, and not already occupied! + if(xTurn) { + gameBoard[row][col] = "X"; + } + else { + gameBoard[row][col] = "O"; + } + + }//end getUserInput + + public static boolean cellAlreadyOccupied(int row, + int col, String[][] gameBoard) { + return !gameBoard[row][col].equals(" "); + }//end cellAlreadyOccupied + + public static String getWinner( + String[][] gameBoard) { + final int ROWS = gameBoard.length; + final int COLS = gameBoard[0].length; + + for (int i = 0; i < ROWS; i++) { + if (!gameBoard[i][0].equals(" ") && + gameBoard[i][0].equals(gameBoard[i][1]) && + gameBoard[i][1].equals(gameBoard[i][2])) { + return gameBoard[i][0]; //we have a match (horizontal)! + } + }//end for + + //check columns + for (int i = 0; i < COLS; i++) { + if (!gameBoard[0][i].equals(" ") && + gameBoard[0][i].equals(gameBoard[1][i]) && + gameBoard[1][i].equals(gameBoard[2][i])) { + return gameBoard[0][i]; //we have a match (vertical)! + } + }//end for + + //check diagonals + //there are two diagonals, which we can test manually / no-loop + + //upper-left to bottom right diagonal + if (!gameBoard[0][0].equals(" ") && + gameBoard[0][0].equals(gameBoard[1][1]) && + gameBoard[1][1].equals(gameBoard[2][2])) { + return gameBoard[0][0]; //we have a diagonal match! + } + + //lower-left to upper right diagonal + if (!gameBoard[2][0].equals(" ") && + gameBoard[2][0].equals(gameBoard[1][1]) && + gameBoard[1][1].equals(gameBoard[0][2])) { + return gameBoard[2][0]; //we have a diagonal match! + } + + //if we get to here... + return ""; //no winner yet! + }//end getWinner + + public static boolean isBoardFull( + String[][] gameBoard) { + + int countFill = 0; + + for(int i = 0; i < gameBoard.length; i++) { + for(int j = 0; j < gameBoard[i].length; j++) { + if(!gameBoard[i][j].equals(" ")) { + countFill++; + } + }//end for j + }//end for i + return countFill == 9; //all 9 spaces filled with non-space + }//end isBoardFull +}//end class