רוק, נייר, מספריים הוא משחק יד שמשחקים שני אנשים. שני האנשים היו אומרים "סלע, נייר, מספריים" ואז יוצרים בו זמנית אחד משלושה אובייקטים (סלע, נייר או מספריים) ביד מושטת. המנצח נקבע על פי תבניות הידיים. מספריים דופקים נייר, נייר דופק סלע, וסלע דופק מספריים. אם שני השחקנים משחקים את אותה מערך ידיים, זה נחשב לשוויון. נכתוב משחק פשוט בג'אווה המדמה סלע, נייר, מספריים כאשר שחקן אחד הוא המשתמש והשחקן השני הוא המחשב.
צעדים
שלב 1. צור את המעמד הראשי וקרא לזה
אבן נייר ומספריים
.
זה יהיה השיעור שבו נכתוב את המשחק. אתה יכול לבחור לקרוא לזה משהו אחר כגון
מִשְׂחָק
אוֹ
רָאשִׁי
. כתוב בהצהרות שיטה לבנאי ולשיטה העיקרית.
מעמד ציבורי RockPaperScissors {public RockPaperScissors () {} main static void main (String args) {}}
שלב 2. צור ספירה של מחוות הידיים (סלע, נייר או מספריים)
יכולנו להשתמש במחרוזות לייצוג סלע, נייר או מספריים, אך ספירה מאפשרת לנו להגדיר מראש את הקבועים שלנו מה שאומר ששימוש בספירה הוא עיצוב טוב יותר. נקרא לסוג enum שלנו
מהלך / לזוז / לעבור
עם הערכים
סלע
עיתון
ו
מספריים
סיכום פרטי העברה {ROCK, PAPER, SCISSORS}
שלב 3. צור שני שיעורים פרטיים
מִשׁתַמֵשׁ
ו
מַחשֵׁב
.
השיעורים האלה ייצגו את השחקנים שלנו במשחק. אתה יכול לבחור להפוך את השיעורים האלה לציבוריים. ה
מִשׁתַמֵשׁ
class תהיה המחלקה שתבקש מהמשתמש אבן, נייר או מספריים, כך שנצטרך לכתוב א
getMove ()
שיטה. ה
מַחשֵׁב
בכיתה יהיה צורך גם
getMove ()
שיטה כך שגם המחשב יכול לבצע מהלך. נכניס מצייני מקום לשיטות אלה ויישם אותן מאוחר יותר. ה
מִשׁתַמֵשׁ
class ידרש קונסטרוקטור שמקים את
סוֹרֵק
אובייקט לקלוט קלט המשתמש. אנו נשים את
סוֹרֵק
כשדה פרטי למשתמש ולאחר מכן ליזום אותו בבנאי. מכיוון שאנו משתמשים ב-
סוֹרֵק
class, עלינו לכתוב עבורו הצהרת יבוא בראש הקוד שלנו. ה
מַחשֵׁב
הכיתה אינה דורשת קונסטרוקטור, ולכן איננו צריכים לכתוב אחד; כאשר אנו יוזמים את
מַחשֵׁב
אובייקט, אנחנו פשוט נתקשר לבנאי ברירת המחדל. הנה מה שלנו
אבן נייר ומספריים
הכיתה נראית כמו עכשיו:
יבוא java.util. Scanner; מעמד ציבורי RockPaperScissors {private enum Move {ROCK, PAPER, SCISSORS} משתמש בכיתה פרטית {private Scanner inputScanner; משתמש ציבורי () {inputScanner = סורק חדש (System.in); } ציבורי העבר getMove () {// TODO: יישום השיטה null; }} מחשב בכיתה פרטית {public Move getMove () {// TODO: יישום שיטה זו null null; }} ציבורי RockPaperScissors () {} main static void main (String args) {}}
שלב 4. כתוב את
getMove ()
שיטה עבור
מַחשֵׁב
מעמד.
שיטה זו תחזיר אקראית
מהלך / לזוז / לעבור
. אנחנו יכולים לקבל מערך של
מהלך / לזוז / לעבור
ספירות על ידי התקשרות אל
ערכים ()
שיטה:
Move.values ()
. כדי לבחור אקראי
מהלך / לזוז / לעבור
ספירה במערך ערכים זה, עלינו ליצור אינדקס אקראי המהווה מספר שלם בין 0 לאורכו של מערך הערכים שלנו. לשם כך נוכל להשתמש ב-
nextInt ()
שיטת ה
אַקרַאִי
מחלקה שאנו צריכים לייבא ממנה
java.util
. לאחר שקיבלנו את המדד האקראי, נוכל להחזיר את
מהלך / לזוז / לעבור
של המדד הזה ממערך הערכים שלנו.
העברה ציבורית getMove () {Move moves = Move.values (); אקראי אקראי = חדש אקראי (); int index = random.nextInt (moves.length); מהלכי החזרה [אינדקס]; }
שלב 5. כתוב את
getMove ()
שיטה עבור
מִשׁתַמֵשׁ
מעמד.
שיטה זו תחזיר א
מהלך / לזוז / לעבור
המתאים למה שהמשתמש יש קלט. אנו מצפים מהמשתמש לכתוב "סלע", "נייר" או "מספריים". ראשית, עלינו לבקש מהמשתמש להזין קלט:
System.out.print ("סלע, נייר או מספריים?")
. לאחר מכן השתמש ב
nextLine ()
שיטת ה
סוֹרֵק
אובייקט כדי לקבל את קלט המשתמש כמחרוזת. כעת עלינו לבדוק אם המשתמש הגיש מהלך תקף, אך נוכל להקל אם המשתמש לא איתם מילה שגויה. אז נבדוק רק אם האות הראשונה של קלט המשתמש היא "R" (לסלע), "P" (לנייר) או "S" (למספריים), ולא יהיה אכפת לנו מהמקרה כי נשתמש תחילה ב-
toUpperCase ()
שיטת ה
חוּט
class להפוך את מחרוזת הקלט של המשתמש לרשת גדולה. אם המשתמש לא הזן קלט נכון מרחוק, נבקש מהמשתמש שוב. לאחר מכן, בהתאם למה שהכניס המשתמש, נחזיר מהלך מקביל.
העבר ציבורי getMove () {// בקש מהמשתמש System.out.print המשתמש ("סלע, נייר או מספריים?"); // קבל את קלט המשתמש String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// המשתמש הזן מתג קלט תקף (FirstLetter) {case 'R': החזר Move. ROCK; מקרה 'P': החזר Move. PAPER; מקרה 'S': החזר Move. SCISSORS; }}} // המשתמש לא הזן קלט חוקי. תבקש שוב. החזר getMove (); }
שלב 6. כתוב א
שחק שוב()
שיטה עבור
מִשׁתַמֵשׁ
מעמד.
המשתמש צריך להיות מסוגל לשחק את המשחק שוב ושוב. על מנת לקבוע אם המשתמש רוצה לשחק שוב, עלינו לכתוב א
שחק שוב()
שיטה המחזירה בוליאני שאומר למשחק אם המשתמש החליט לשחק שוב או לא. בשיטה זו אנו משתמשים ב-
סוֹרֵק
שיזמנו בעבר בבנאי לקבל "כן" או "לא" מהמשתמש. נבדוק רק אם האות הראשונה היא 'Y' כדי לקבוע אם המשתמש רוצה לשחק שוב. כל קלט אחר אומר שהמשתמש לא ירצה לשחק שוב.
public boolean playAgain () {System.out.print ("האם אתה רוצה לשחק שוב?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); החזר userInput.charAt (0) == 'Y'; }
שלב 7. חבר את
מִשׁתַמֵשׁ
ו
מַחשֵׁב
שיעורים יחד ב
אבן נייר ומספריים
מעמד.
כעת, לאחר שסיימנו לכתוב את
מִשׁתַמֵשׁ
ו
מַחשֵׁב
כיתות, אנו יכולים להתמקד בעבודה על המשחק שלנו בפועל. צור שדות פרטיים עבור
מִשׁתַמֵשׁ
ו
מַחשֵׁב
שיעורים ב
אבן נייר ומספריים
מעמד. נצטרך לגשת לשדות אלה כדי לגשת ל
getMove ()
שיטות כאשר אנו משחקים את המשחק. בבונה עבור
אבן נייר ומספריים
class, ליזום שדות אלה. נצטרך גם לעקוב אחר הציון
userScore
ו
מחשב ממוחשב
שדות, אותם עלינו ליזום כ- 0 בבנאי. עלינו לעקוב גם אחר מספר המשחקים, שיהיה גם תחום שיוזם כ- 0.
משתמש משתמש פרטי; מחשב מחשב פרטי; int userScore; int computerScore; int int numberOfGames; ציבורי RockPaperScissors () {user = new User (); מחשב = מחשב חדש (); userScore = 0; computerScore = 0; numberOfGames = 0; }
שלב 8. הארך את
מהלך / לזוז / לעבור
enum לכלול שיטה שאומרת לנו איזה מהלך מנצח בכל מקרה ומקרה.
עלינו לכתוב א
CompareMoves ()
שיטה המחזירה 0 אם המהלכים זהים, 1 אם המהלך הנוכחי מנצח את המהלך השני ו- -1 אם המהלך הנוכחי מפסיד למהלך השני. זה יהיה שימושי לקביעת המנצח במשחק. כדי ליישם שיטה זו תחילה נחזיר 0 אם המהלכים זהים ולכן יש לנו שוויון. לאחר מכן כתוב הצהרת מתג להחזרת 1 או -1.
מסגרת פרטית העברה {סלע, נייר, מספריים; /** * משווה מהלך זה עם מהלך אחר לקביעת שוויון, ניצחון או * הפסד. * * @param otherMove * לעבור להשוות ל- * @return 1 אם מהלך זה מנצח את המהלך השני, -1 אם המהלך הזה מפסיד * למהלך השני, 0 אם המהלכים האלה משתווים * / public int comparMoves (Move otherMove) { / / Tie if (this == otherMove) החזר 0; switch (זה) {case ROCK: return (otherMove == SCISSORS? 1: -1); PAPER case: return (otherMove == ROCK? 1: -1); מספריים מספר: return (otherMove == PAPER? 1: -1); } // לעולם לא אמור להגיע לכאן החזר 0; }}
שלב 9. צור א
התחל משחק()
שיטה ב
אבן נייר ומספריים
מעמד.
שיטה זו תהיה משחק המשחק. התחל בלשים פשוט
System.out.println
בשיטה.
public void startGame () {System.out.println ("סלע, נייר, מספריים!"); }
שלב 10. קבל מהלכים מהמשתמש ומהמחשב
בתוך ה
התחל משחק()
שיטה, השתמש ב
getMove ()
שיטות מתוך
מִשׁתַמֵשׁ
הכיתה וה
מַחשֵׁב
class להשיג את המשתמש ואת המהלכים של המחשב.
העבר userMove = user.getMove (); העברת computerMove = computer.getMove (); System.out.println ("\ n שיחקת" + userMove + "."); System.out.println ("מחשב שיחק" + computerMove + ". / N");
שלב 11. השווה בין שני המהלכים וקבע אם המשתמש זכה או המחשב זכה
להשתמש ב
CompareMoves ()
שיטה מתוך
מהלך / לזוז / לעבור
הסכמה לקבוע אם המשתמש זכה או לא. אם המשתמש זכה, הגדילו את ציון המשתמש ב -1. אם המשתמש הפסיד, הגדילו את ציון המחשב ב -1. אם הייתה שוויון, אל תגדילו אף אחד מהציונים. לאחר מכן הגדילו את מספר המשחקים שאחד משחק.
int comparMoves = userMove.compareMoves (computerMove); switch (comparMoves) {case 0: // Tie System.out.println ("עניבה!"); לשבור; מקרה 1: // משתמש זוכה System.out.println (userMove + "פעימות" + computerMove + ". ניצחת!"); userScore ++; לשבור; מקרה -1: // המחשב זוכה System.out.println (computerMove + "פעימות" + userMove + ". הפסדת."); computerScore ++; לשבור; } numberOfGames ++;
שלב 12. שאל אם המשתמש רוצה לשחק שוב
אם המשתמש רוצה לשחק שוב, התקשר
התחל משחק()
שוב. אחרת תתקשר
printGameStats ()
שידפיס את הנתונים הסטטיסטיים של המשחק. נכתוב את השיטה הזו בשלב הבא.
אם (user.playAgain ()) {System.out.println (); התחל משחק(); } אחר {printGameStats (); }
שלב 13. כתוב את
printGameStats ()
שיטה.
שיטה זו תציג את הנתונים הסטטיסטיים של המשחק: מספר הניצחונות, מספר ההפסדים, מספר הקשרים, מספר המשחקים שיחקו ואחוז המשחקים שהמשתמש זכה בהם. אחוז המשחקים שניצחו מחושב לפי (# ניצחונות + (# תיקו/2))/(# משחקים שיחקו). שיטה זו משתמשת
System.out.printf
להדפסת טקסט מעוצב.
private void printGameStats () {int wins = userScore; int הפסדים = computerScore; int ties = numberOfGames - userScore - computerScore; אחוז כפול זכה = (מנצח + ((כפול) קשרים) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // כותרות הדפסה System.out.printf ("| %6s | %6s | %6s | %12s | %14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE זכית"); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // ערכי הדפסה System.out.printf ("| %6d | %6d | %6d | %12d | %13.2f %% | / n", ניצחונות, הפסדים, קשרים, numberOfGames, אחוזים * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); }
שלב 14. התחל את המשחק במעמד הראשי
בכיתה הראשית, אתחל מופע של
אבן נייר ומספריים
בכיתה והתקשר ל
התחל משחק()
שיטה.
public static void main (String args) {RockPaperScissors game = RockPaperScissors חדש (); game.startGame (); }
שלב 15. בדוק את המשחק שלך
כעת, לאחר שעברנו את כל המאמצים בכתיבת המשחק "רוק, נייר, מספריים", הגיע הזמן לאסוף ולבדוק הכל!
תוכנית לדוגמא
יבוא java.util. Random; יבוא java.util. Scanner; מעמד ציבורי RockPaperScissors {משתמש פרטי פרטי; מחשב מחשב פרטי; int userScore; int computerScore; int int numberOfGames; מסגרת פרטית העברה {סלע, נייר, מספריים; /** * משווה מהלך זה עם מהלך אחר לקביעת שוויון, ניצחון או * הפסד. * * @param otherMove * לעבור להשוות ל- * @return 1 אם מהלך זה מנצח את המהלך השני, -1 אם המהלך הזה מפסיד * למהלך השני, 0 אם המהלכים האלה משתווים * / public int comparMoves (Move otherMove) { / / Tie if (this == otherMove) החזר 0; switch (זה) {case ROCK: return (otherMove == SCISSORS? 1: -1); PAPER case: return (otherMove == ROCK? 1: -1); מספריים במקרה: return (otherMove == PAPER? 1: -1); } // לעולם לא אמור להגיע לכאן החזר 0; }} משתמש בכיתה פרטית {input Scanner פרטי סורק; משתמש ציבורי () {inputScanner = סורק חדש (System.in); } העברה ציבורית getMove () {// בקש מהמשתמש System.out.print המשתמש ("סלע, נייר או מספריים?"); // קבל את קלט המשתמש String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// המשתמש הזן מתג קלט תקף (FirstLetter) {case 'R': החזר Move. ROCK; מקרה 'P': החזר Move. PAPER; מקרה 'S': החזר Move. SCISSORS; }}} // המשתמש לא הזן קלט חוקי. תבקש שוב. החזר getMove (); } playolay boolean ציבורי () {System.out.print ("האם אתה רוצה לשחק שוב?"); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); החזר userInput.charAt (0) == 'Y'; }} מחשב בכיתה פרטית {public Move getMove () {Move moves = Move.values (); אקראי אקראי = חדש אקראי (); int index = random.nextInt (moves.length); מהלכי החזרה [אינדקס]; }} Public RockPaperScissors () {user = new user (); מחשב = מחשב חדש (); userScore = 0; computerScore = 0; numberOfGames = 0; } startGame () חלל ציבורי () {System.out.println ("סלע, נייר, מספריים!"); // קבל מהלכים העבר userMove = user.getMove (); העברת computerMove = computer.getMove (); System.out.println ("\ n שיחקת" + userMove + "."); System.out.println ("מחשב שיחק" + computerMove + ". / N"); // השווה מהלכים וקבע מנצח int comparMoves = userMove.compareMoves (computerMove); switch (comparMoves) {case 0: // Tie System.out.println ("עניבה!"); לשבור; מקרה 1: // משתמש זוכה System.out.println (userMove + "פעימות" + computerMove + ". ניצחת!"); userScore ++; לשבור; מקרה -1: // המחשב זוכה System.out.println (computerMove + "פעימות" + userMove + ". הפסדת."); computerScore ++; לשבור; } numberOfGames ++; // בקש מהמשתמש לשחק שוב אם (user.playAgain ()) {System.out.println (); התחל משחק(); } אחר {printGameStats (); }} /*** מדפיס את הנתונים הסטטיסטיים של המשחק. מחשב קשרים כ- 1/2 ניצחון ב- * אחוז זכה. */ private void printGameStats () {int wins = userScore; int הפסדים = computerScore; int ties = numberOfGames - userScore - computerScore; אחוז כפול זכה = (מנצח + ((כפול) קשרים) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // הדפס כותרות System.out.printf ("| %6s | %6s | %6s | %12s | %14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE זכית"); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // ערכי הדפסה System.out.printf ("| %6d | %6d | %6d | %12d | %13.2f %% | / n", ניצחונות, הפסדים, קשרים, numberOfGames, אחוזים * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); } private void printDashes (int numberOfDashes) {for (int i = 0; i <numberOfDashes; i ++) {System.out.print ("-"); }} main static void main (String args) {RockPaperScissors game = RockPaperScissors חדש (); game.startGame (); }}
