Wir werden die Grammatik und Spezifikationen von ** Java ** basierend auf dem von uns erstellten Janken-Spiel überprüfen.
Die Regeln folgen den allgemeinen Regeln von Janken. Der Spieler und COM haben jedoch 5 Punkte körperlicher Stärke. Wenn Sie die Janken gewinnen, können Sie Ihrem Gegner 1 Punkt Schaden zufügen. Der Gewinner ist derjenige, der zuerst die körperliche Stärke des Gegners auf 0 Punkte oder weniger reduziert. Es findet keine Auslosung statt und der Vorgang wird fortgesetzt, bis entweder der Spieler oder COM gewinnt.
Der Verarbeitungsinhalt wird auf der Konsole angezeigt, und der auf der Konsole angezeigte Inhalt wird auch in die Protokolldatei ausgegeben.
Java ist eine Sprache, die vom einst existierenden US-amerikanischen IT-Unternehmen ** Sun Microsystems (jetzt Oracle America) ** entwickelt wurde. Seit der Ankündigung von JDK 1.0 im Januar 1996 wurde es kontinuierlich aktualisiert, und Java SE 14, das im März 2020 angekündigt wurde, wird die neueste Version sein.
Nach dem Ursprung der Sprache scheint die Entwicklung ursprünglich als eingebettete Sprache für auf C ++ basierende Haushaltsgeräte begonnen zu haben. Mitten in der Entwicklung hat sich das Ziel der Integration jedoch von Haushaltsgeräten auf PDAs verlagert und ist auch zu einer Sprache für die Webentwicklung geworden. Vielleicht aufgrund dieser unterschiedlichen Bereiche hat es sich zu einer äußerst vielseitigen Sprache entwickelt, die heute in einer Vielzahl von Branchen verwendet wird. Wenn Sie damit vertraut sind, wird es auch bei der Entwicklung von Android-Apps verwendet. ~~ Kotlin "(nicht mehr in der Java Paisen-Ära)" ~~
Java hat eine hohe Zuverlässigkeit aufgebaut, da es seit über 20 Jahren an vorderster Front aktiv ist. Aufgrund des Aufstiegs der JVM-Sprache und der schlechten Ankündigungsmethode von Oracle ~~ "Bezahlt von Java SE 11" Es ist nicht zu leugnen, dass die Popularität des Produkts durch das weit verbreitete Missverständnis, dass es getan wird, gekühlt wurde !?
Die Nachfrage ist jedoch immer noch eine der höchsten in allen Sprachen, und selbst wenn die Optionen für neue Entwicklungsprojekte entfernt werden, bleiben in Java geschriebene Systemwartungs- und Reparaturprojekte bestehen, sodass wir dies auch in Zukunft tun werden. Es besteht kein Zweifel, dass es noch Jahrzehnte verwendet wird.
Verwenden Sie zum Erstellen einer Java-Entwicklungsumgebung ein Paket namens ** JDK (Java Development Kit) , eine Sammlung von Programmen, die für die Java-Entwicklung erforderlich sind, oder eine IDE, die ein JDK () enthält Eclipse ** und ** IntelliJ IDEA ** sind die wichtigsten).
In diesem Artikel erklären wir das Verfahren zum Erstellen einer Entwicklungsumgebung mit ** OpenJDK (genau genommen OpenJDK 14x-Serie) **, einem der von verschiedenen Organisationen angekündigten JDKs.
** * Dies ist ein Kommentar für die Windows 10 64-Bit-Version. Wir haben den Betrieb in anderen Umgebungen nicht bestätigt. ** ** **
Laden Sie zunächst das Open JDK herunter. Wechseln Sie zu der Site, die OpenJDK verwaltet.
Im Block unter der Überschrift ** Download ** in der Mitte der Site befindet sich ein Link, über den Sie zur Download-Seite der OpenJDK 14x-Serie springen können. Klicken Sie auf den Link, um zur Zielseite zu gelangen.
Nahe der Mitte der Download-Seite befindet sich ein Download-Link für das JDK, der jedem Betriebssystem, Linux, MacOS und Windows entspricht. Klicken Sie auf den Link JDK für Windows, um den Download zu starten. Ich konnte das verdammte kleine Fisch-WLAN in ungefähr 1 Minute bei mir zu Hause herunterladen. Wenn es sich also um ein durchschnittliches WLAN oder ein Kabel handelt, sollte es sofort abgeschlossen sein.
Die heruntergeladene Datei sollte im ZIP-Format komprimiert sein. Entpacken Sie sie daher. Das entpackte Verzeichnis sollte ein Verzeichnis mit einem Namen wie ** jdk-14.0.1 ** haben. Dies ist der Hauptteil von OpenJDK, der den Java-Compiler usw. enthält.
Bei der Erstellung der Entwicklungsumgebung in anderen Programmiersprachen kann es erforderlich sein, das Installationsprogramm usw. von hier aus zu starten und mit der Erstellung der Entwicklungsumgebung fortzufahren. In Java ist dies jedoch vorerst das Ende.
Überprüfen Sie, ob das OpenJDK korrekt heruntergeladen und entpackt wurde.
Platzieren Sie zunächst den Hauptteil von OpenJDK (ein Verzeichnis mit dem Namen ** jdk-14.0.1 **) direkt unter dem Laufwerk C.
Stellen Sie als Nächstes sicher, dass die in diesem Verzeichnis gespeicherten Verzeichnisse ** bin ** die ausführbaren Dateien ** java.exe ** und ** javac.exe ** enthalten. Ersteres ist eine App zum Ausführen von in Java geschriebenen Programmen, und letzteres ist ein Java-Compiler.
Starten Sie zum Überprüfen des Vorgangs eine Shell wie die Eingabeaufforderung oder PowerShell und geben Sie den Befehl wie unten gezeigt ein. Es ist in Ordnung, wenn Folgendes angezeigt wird.
Wenn es so angezeigt wird, ist es OK
C:\jdk-14.0.1\bin> .\java.exe -version
openjdk version "14.0.1" 2020-04-14
OpenJDK Runtime Environment (build 14.0.1+7)
OpenJDK 64-Bit Server VM (build 14.0.1+7, mixed mode, sharing)
C:\jdk-14.0.1\bin>.\javac.exe -version
javac 14.0.1
C:\jdk-14.0.1\bin>
Sie können Java im obigen Zustand entwickeln, aber lassen Sie uns Path in das Verzeichnis ** bin ** oben einfügen, damit es einfach zu entwickeln ist.
Es ist perfekt, wenn Sie dies tun können. Danke für deine harte Arbeit.
Was die grundlegende Grammatik betrifft, lesen Sie bitte den Quellcode am Ende des Artikels und notieren Sie Dinge, die nicht aus dem Quellcode gelesen werden können, und Dinge, die Sie beachten sollten.
Die Erweiterung ist **. Java **.
Wenn Sie die Entwicklungsumgebung gemäß dem in diesem Artikel beschriebenen Verfahren erstellen (es scheint für jede Entwicklungsumgebung unterschiedlich zu sein), lautet der Standardzeichencode ** MS932 **. MS932 ist eine Erweiterung von ** Shift JIS ** mit einem Zeichencode, der auch als ** windows-31j ** bezeichnet wird. Wenn der Quellcode kein Japanisch enthält, können Sie ihn in Shift JIS oder UTF-8 schreiben. Wenn der Quellcode Japanisch enthält, können Sie ihn in Shift JIS schreiben.
Wenn Sie den Standardzeichencode Ihrer Umgebung kennen möchten, führen Sie bitte das folgende Programm aus.
Test.java
class Test {
public static void main(String[] args) {
System.out.println(System.getProperty("file.encoding"));
}
}
Übrigens (das ist bei mir der Fall), ich denke, es gibt einige Leute, die Japanisch in die Quelldatei aufnehmen wollen, aber den Zeichencode in UTF-8 schreiben wollen. Mit dem Java-Compiler können Sie den Zeichencode zur Kompilierungszeit angeben. Lesen Sie daher den folgenden Befehl.
UTF-Kompilieren Sie mit 8
C:\Users\AGadget> javac .\Test.java -encoding UTF-8
Es scheint, dass Java-Codierungsstandards von verschiedenen Organisationen angekündigt wurden.
Ist es nicht besser, sich auf einen der Codierungsstandards zu beziehen?
In diesem Abschnitt wird die Vorgehensweise von der Kompilierung bis zur Ausführung beschrieben.
Bereiten Sie zunächst die Quelldatei vor. In Java scheint es eine Codierungsmethode zu sein, eine Klasse in einer Datei zu speichern und den Dateinamen mit dem Klassennamen abzugleichen (Hinweis: Laut Recherche des Posters). Die folgenden Beispieldateien folgen diesem.
Test.java
class Test {
public static void main(String[] args) {
System.out.println("Hello world.");
}
}
Sobald die Quelldatei fertig ist, kompilieren Sie sie, um eine Zwischendatei (.class-Datei) zu generieren.
kompilieren
C:\Users\AGadget> javac .\Test.java
C:\Users\AGadget>
Sie sollten jetzt eine Zwischendatei mit dem Namen ** Test.class ** haben. Führen Sie dies mit java.exe aus.
Lauf
C:\Users\AGadget> java Test
Hello world.
C:\Users\AGadget>
Das Verfahren zum Kompilieren und Ausführen von Java ist etwas kompliziert. Lesen Sie daher bei Bedarf einen anderen Kommentar.
In der Entwicklungsumgebung, die nach der in diesem Artikel beschriebenen Prozedur erstellt wurde, lautet der Standardzeichencode des Compilers ** Shift JIS **. Wenn Sie mit einem beliebigen Zeichencode kompilieren möchten, drücken Sie den Befehl wie folgt.
UTF-Kompilieren Sie mit 8
C:\Users\AGadget> javac .\Test.javaa -encoding UTF-8
C:\Users\AGadget>
Java-Einstiegspunkte sind die folgenden Methoden.
public static void main(String[] args) {
//Dies ist der Einstiegspunkt
}
In der Regel dient das Ändern des obigen Formats, z. B. das Ändern von ** public ** in ** private ** oder das Ändern des Methodennamens von ** main ** in ** main **, als Einstiegspunkt. Bitte beachten Sie, dass es nicht erkannt wird.
Im Gegensatz zu Sprachen, die Klassen in einer beliebigen Sprache verwenden, oder Sprachen, in denen es überhaupt keine Klassen gibt, muss bei Java die gesamte Verarbeitung in einer der Klassen gespeichert werden. Dies gilt auch für die Hauptmethode, die der Einstiegspunkt für Java ist, und wir müssen eine Klasse definieren, um die Hauptmethode zu speichern.
Main.java
/**
*Hauptklasse mit der Hauptmethode
*/
class Main {
/**
*Hauptmethode
*/
public static void main(String[] args) {
System.out.println("Hello world.");
}
}
Abgesehen davon war dies eine der verwirrenden Spezifikationen, als ich Java zum ersten Mal berührte. Bis dahin hatte ich nur C / JavaScript berührt, daher schien diese Spezifikation ziemlich seltsam. ~~ Um ehrlich zu sein, bin ich immer noch nicht daran gewöhnt. ~~
In Java wird der Operator ** == ** verwendet, um zu vergleichen und zu bestimmen, ob die Referenzen gleich sind, und die Methode ** equals ** wird verwendet, um zu vergleichen und zu bestimmen, ob die Werte gleich sind.
Test.java
class Test {
public static void main(String[] args) {
StringBuilder a = new StringBuilder("Hello world.");
StringBuilder b = new StringBuilder("Hello world.");
System.out.println(a.toString() == b.toString());
System.out.println(a.toString().equals(b.toString()));
}
}
Versuche zu rennen
C:\Users\AGadget> javac .\Test.java
C:\Users\AGadget> java Test
false
true
C:\Users\AGadget>
Siehe das folgende Beispiel.
Test.java
class Test {
public static void main(String[] args) {
System.out.println(testMethod("Windows Mobile"));
}
private static String testMethod(String OS) {
if (OS.equals("AndroidOS")) {
return "Android OS ist orientiert";
}
if (OS.equals("iOS")) {
return "iOS ist orientiert";
}
if (OS.equals("BlackBerry")) {
return "BlackBerry ist die Orientierung";
}
System.out.println("[Error]Winmo ist NG. . . ");
System.exit(0);
}
}
Auf den ersten Blick scheint dieses Programm problemlos zu kompilieren, wird aber tatsächlich als Syntaxfehler abgespielt.
C:\Users\AGadget> javac .\Test.java
.\Test.java:19:Error:Keine return-Anweisung angegeben
}
^
1 Fehler
C:\Users\AGadget>
In Java scheint es, dass die return-Anweisung mit ** allen möglichen Zweigen ** geschrieben werden muss, wenn die Methode einen Rückgabewert zurückgibt.
Sie können es kompilieren, indem Sie es wie folgt ändern.
Test.java
class Test {
public static void main(String[] args) {
System.out.println(testMethod("Windows Mobile"));
}
private static String testMethod(String OS) {
if (OS.equals("AndroidOS")) {
return "Android OS ist orientiert";
}
if (OS.equals("iOS")) {
return "iOS ist orientiert";
}
if (OS.equals("BlackBerry OS")) {
return "BlackBerry OS ist die Orientierung";
}
System.out.println("[Error]Winmo ist NG. . . ");
System.exit(0);
return ""; //Implementiert, weil es syntaktisch notwendig ist
}
}
Main.java
import java.util.Scanner;
/**
*Dies ist die Hauptklasse des Janken-Spiels.
* @author AGadget
*/
class Main {
/**
*Dies ist die Hauptmethode
*/
public static void main(String[] args) {
StandardIO standardIO = StandardIO.getInstance();
Player player = new Player(5, "Qii Taro");
COM com = new COM(5, "COM");
TurnCount turnCount = new TurnCount();
while (player.canGame() && com.canGame()) {
turnCount.countUp();
turnCount.printTurnCountMessage();
player.printStatusMessage(com.getNameWidth());
com.printStatusMessage(player.getNameWidth());
standardIO.printlnEmptyLine(1);
player.choiceAction();
com.choiceAction();
standardIO.printlnEmptyLine(1);
standardIO.println(generateChoicedActionMessage(player.getAction(), com.getAction()));
player.damageProcess(com.getAction());
com.damageProcess(player.getAction());
standardIO.printlnEmptyLine(5);
}
standardIO.println(generateGameResultMessage(player.canGame(), com.canGame(), player.getName(), com.getName()));
standardIO.printlnEmptyLine(1);
pause();
}
/**
*Eine Methode, die eine Nachricht erstellt und zurückgibt, die die von beiden Spielfiguren ausgewählte Aktion darstellt.
* @param action1 Dies ist die Aktion, die von Spielcharakter 1 ausgewählt wurde.
* @param action2 Dies ist die Aktion, die von Spielcharakter 2 ausgewählt wurde.
* @Rückmeldung
*/
private static String generateChoicedActionMessage(String action1, String action2) {
return "> " + action1 + " vs " + action2;
}
/**
*Eine Methode, die eine Nachricht erstellt und zurückgibt, die das Ergebnis des Spiels darstellt
* @param canGame1 Flag, ob Spielcharakter 1 das Spiel fortsetzen kann
* @param canGame2 Markiert, dass Spielcharakter 2 das Spiel fortsetzen kann
* @param name1 Der Name des Spielcharakters 1
* @param name2 Der Name des Spielcharakters 2
* @Rückmeldung
*/
private static String generateGameResultMessage(boolean canGame1, boolean canGame2, String name1, String name2) {
if (canGame1 && !canGame2) {
return "> " + name1 + "Es ist ein Sieg!";
}
if (!canGame1 && canGame2) {
return "> " + name2 + "Es ist ein Sieg!";
}
System.out.println("[Error]Ein Unentschieden ist aufgetreten");
System.exit(0);
return ""; //Ich schreibe eine return-Anweisung, die für die Verarbeitung nicht erforderlich ist, da sie einen Grammatikfehler verursacht
}
/**
*Eine Methode, die die Verarbeitung stoppt, bis die Eingabetaste gedrückt wird.
*/
private static void pause() {
System.out.print("Drücken Sie Enter. . . ");
Scanner scanner = new Scanner(System.in);
scanner.nextLine();
}
}
StandardIO.java
import java.util.Calendar;
import java.text.SimpleDateFormat;
import java.io.IOException;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.util.Scanner;
/**
*Eine Klasse, die alle Ein- und Ausgaben in und aus der Konsolenprotokolldatei verarbeitet.
*Nimmt Singleton-Entwurfsmuster an
* @author AGadget
*/
class StandardIO {
private static StandardIO instanceStandardIO = new StandardIO(); //Es ist eine Instanz dieses Objekts
private String logFilePath; //Protokolldateipfad
/**
*Es ist ein Konstruktor
*Mit dem Kalenderobjekt wird der Name der Protokolldatei aus dem aktuellen Datum und der aktuellen Uhrzeit erstellt
*/
private StandardIO() {
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyMMddHHmmss");
this.logFilePath = "log_" + simpleDateFormat.format(calendar.getTime()) + ".txt";
}
/**
*Eine Methode, die eine Instanz dieses Objekts zurückgibt
*Diese Methode ist erforderlich, da das Singleton-Entwurfsmuster verwendet wird.
* @return Eine Instanz dieses Objekts
*/
public static StandardIO getInstance() {
return instanceStandardIO;
}
/**
*Eine Methode, die die im Argument angegebene Zeichenfolge an die Konsole und die Protokolldatei ausgibt.
*Am Ende des Ausgabewerts wird ein Zeilenvorschubzeichen hinzugefügt
* @param message Ausgabezeichenfolge
*/
void println(String message) {
System.out.println(message);
try {
FileWriter fileWriter = new FileWriter(this.logFilePath, true);
PrintWriter printWriter = new PrintWriter(new BufferedWriter(fileWriter));
printWriter.println(message);
printWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
*Eine Methode, die eine beliebige Anzahl von Leerzeilen an die Konsole und die Protokolldatei ausgibt.
*Die Anzahl der Zeilen kann durch ein Argument angegeben werden
* @param numberOfEmptyLine
*/
void printlnEmptyLine(int numberOfEmptyLine) {
for (int i = 0; i < numberOfEmptyLine; i += 1) {
this.println("");
}
}
/**
*Eine Methode, die die im Argument angegebene Zeichenfolge an die Konsole und die Protokolldatei ausgibt.
*Am Ende des Ausgabewerts befindet sich kein Zeilenvorschubzeichen
* @param message Ausgabezeichenfolge
*/
void print(String message) {
System.out.print(message);
try {
FileWriter fileWriter = new FileWriter(this.logFilePath, true);
PrintWriter printWriter = new PrintWriter(new BufferedWriter(fileWriter));
printWriter.print(message);
printWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
/**
*Eine Methode, die Standardeingaben akzeptiert, den Eingabewert in eine Protokolldatei ausgibt und an den Aufrufer zurückgibt.
* @Rückgabe Standard-Eingabewert
*/
String readLine() {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
this.printlnOnlyToLogFile(input);
return input;
}
/**
*Diese Methode gibt die im Argument "nur" angegebene Zeichenfolge in die Protokolldatei aus.
*→ Es wird davon ausgegangen, dass es als Set mit der für die Standardeingabeverarbeitung zuständigen Methode verwendet wird.
*Am Ende des Ausgabewerts wird ein Zeilenvorschubzeichen hinzugefügt
* @param message Ausgabezeichenfolge
*/
private void printlnOnlyToLogFile(String message) {
try {
FileWriter fileWriter = new FileWriter(this.logFilePath, true);
PrintWriter printWriter = new PrintWriter(new BufferedWriter(fileWriter));
printWriter.println(message);
printWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
GameCharacter.java
/**
*Eine abstrakte Klasse, die einen Spielcharakter darstellt
* @author AGadget
*/
abstract class GameCharacter {
protected StandardIO standardIO = StandardIO.getInstance(); //Das Objekt, das für die Ausgabeverarbeitung verantwortlich ist
private final int MAX_LIFE = 5; //Dies ist die Obergrenze der körperlichen Stärke, die allen Spielfiguren gemeinsam ist.
private int life; //Es ist körperliche Stärke
private String name; //Ist der Name
protected final String[] ACTIONS = {"Schmiere", "Choki", "Par"}; //Liste der Aktionen, die ausgewählt werden können
protected String action; //Die Aktion der Wahl
/**
*Eine abstrakte Methode zum Auswählen einer Aktion
*Implementieren Sie den Prozess der Auswahl einer Aktion auf irgendeine Weise und weisen Sie die ausgewählte Aktion dem Feld zu, in dem sich die ausgewählte Aktion befindet.
*/
abstract void choiceAction();
/**
*Es ist ein Konstruktor
* @param initialLife Körperliche Stärke zu Beginn des Spiels
* @param name Der Name des Spielcharakters
*/
GameCharacter(int initialLife, String name) {
if (initialLife < 0 && initialLife > this.MAX_LIFE ? true : false) {
System.out.println("[Error]Der Anfangswert zu Beginn des Spiels ist ungültig (" + initialLife + "）");
System.exit(0);
}
this.life = initialLife;
this.name = name;
}
/**
*Es ist eine Methode, um zu antworten, ob das Spiel fortgesetzt werden kann
* @return Gibt wenn möglich true zurück
*/
boolean canGame() {
return this.life > 0 ? true : false;
}
/**
*Eine Methode, die die Breite des Namens zurückgibt
* String.length()Im Gegensatz zu dem Wert, der von usw. erhalten werden kann, wird der Wert zurückgegeben, der mit Zeichen halber Breite als 1 und Zeichen voller Breite als 2 gezählt wird.
*/
int getNameWidth() {
char[] nameToCharArray = this.name.toCharArray();
int nameWidth = 0;
for (int i = 0; i < nameToCharArray.length; i += 1) {
nameWidth += String.valueOf(nameToCharArray[i]).getBytes().length == 1 ? 1 : 2;
}
return nameWidth;
}
/**
*Eine Methode, die eine Nachricht über ihren eigenen Status zurückgibt
*Die Nachricht besteht aus einem Namensteil und einem Teil der körperlichen Stärke
*→ Stellen Sie sicher, dass der Namensteil dieselbe Länge und Breite wie der Name des anderen Teilnehmers hat.
*→ Der Teil der physischen Stärke wird wie ein Indikator für die physische Stärke mithilfe von Symbolen ausgedrückt.
* @param oppositionNameWidth Die Breite des Namens des Gegners (ein Sonderwert, der für Zeichen mit halber Breite als 1 und für Zeichen mit voller Breite als 2 gezählt wird)
*/
void printStatusMessage(int opponentNameWidth) {
StringBuilder namePart = new StringBuilder(this.name);
for (int i = 0; i < opponentNameWidth - this.getNameWidth(); i += 1) {
namePart.append(" ");
}
StringBuilder lifePart = new StringBuilder();
for (int i = 0; i < this.life; i += 1) {
lifePart.append("■");
}
for (int i = 0; i < this.MAX_LIFE - this.life; i += 1) {
lifePart.append("□");
}
standardIO.println(namePart.toString() + ": " + lifePart.toString());
}
/**
*Eine Methode, die die ausgewählte Aktion zurückgibt
* @return Die ausgewählte Aktion
*/
String getAction() {
return this.action;
}
/**
*Es ist eine Methode, die mit Schäden umgeht
*Überprüfen Sie, ob durch die Kombination Ihrer eigenen und der Aktionen des Gegners Schaden entsteht, und reduzieren Sie Ihre körperliche Stärke, wenn Schaden auftritt
* @param gegnerAktion Die Aktion des Gegners
*/
void damageProcess(String opponentAction) {
if (this.action.equals(this.ACTIONS[0]) && opponentAction.equals(this.ACTIONS[2])
|| this.action.equals(this.ACTIONS[1]) && opponentAction.equals(this.ACTIONS[0])
|| this.action.equals(this.ACTIONS[2]) && opponentAction.equals(this.ACTIONS[1])
) {
this.life -= 1;
return;
}
}
/**
*Eine Methode, die einen Namen zurückgibt
* @Name zurückgeben
*/
String getName() {
return this.name;
}
}
Player.java
/**
*Eine Klasse, die einen Spieler repräsentiert
* @author AGadget
*/
class Player extends GameCharacter {
/**
*Es ist ein Konstruktor
* @param initialLife Körperliche Stärke zu Beginn des Spiels
* @param name Der Name des Spielcharakters
*/
Player(int initialLife, String name) {
super(initialLife, name);
}
/**
*Eine Methode zum Auswählen einer Aktion
*Da es sich um einen Prozess für Spieler handelt, haben wir einen Prozess implementiert, der Standardeingaben verwendet.
*/
@Override
void choiceAction() {
String prompt = this.generatePrompt();
while (true) {
standardIO.print(prompt);
String input = standardIO.readLine();
try {
this.action = this.ACTIONS[Integer.parseInt(input) - 1];
return;
} catch (Exception error) {
standardIO.printlnEmptyLine(1);
standardIO.println(">Illegale Eingabe");
standardIO.println(">Bitte erneut eingeben");
standardIO.printlnEmptyLine(1);
}
}
}
/**
*Eine Methode, die die für die Verarbeitung der Aktionsauswahl erforderliche Eingabeaufforderung erstellt und zurückgibt.
* @Eingabeaufforderungszeichenfolge zurückgeben
*/
private String generatePrompt() {
StringBuilder prompt = new StringBuilder();
for (int i = 0; i < this.ACTIONS.length; i += 1) {
prompt.append("[" + (i + 1) + "] " + this.ACTIONS[i] + " ");
}
prompt.append(": ");
return prompt.toString();
}
}
COM.java
import java.util.Random;
/**
*Eine Klasse, die COM darstellt
* @author AGadget
*/
class COM extends GameCharacter {
/**
*Es ist ein Konstruktor
* @param initialLife Körperliche Stärke zu Beginn des Spiels
* @param name Der Name des Spielcharakters
*/
COM(int initialLife, String name) {
super(initialLife, name);
}
/**
*Eine Methode zum Auswählen einer Aktion
*Da es sich um einen Prozess für COM handelt, haben wir einen Prozess implementiert, der Zufallszahlen verwendet.
*/
@Override
void choiceAction() {
Random random = new Random();
this.action = ACTIONS[random.nextInt(ACTIONS.length)];
}
}
TurnCount.java
/**
*Eine Klasse, die die Anzahl der Umdrehungen darstellt
* @author AGadget
*/
class TurnCount {
private StandardIO standardIO = StandardIO.getInstance(); //Das Objekt, das für die Ausgabeverarbeitung verantwortlich ist
private int turnCount; //Die Anzahl der Umdrehungen
/**
*Es ist ein Konstruktor
*/
TurnCount() {
turnCount = 0;
}
/**
*Es ist eine Methode, um die Anzahl der Windungen zu erhöhen
*/
void countUp() {
this.turnCount += 1;
}
/**
*Eine Methode, die die aktuelle Anzahl der Umdrehungen als Nachricht ausgibt
*/
void printTurnCountMessage() {
standardIO.println("[Nein." + this.turnCount + "Wende】");
}
}
Recommended Posts