Nous vérifierons la grammaire et les spécifications de ** Java ** en utilisant notre propre jeu Janken (like) comme thème.
Les règles suivent les règles générales de Janken. Cependant, le joueur et le COM ont 5 points de force physique, et si vous gagnez le Janken, vous pouvez faire 1 point de dommage à votre adversaire. Le gagnant est celui qui réduit la force physique de l'adversaire à 0 point ou moins en premier. Aucun tirage au sort n'aura lieu et le processus se poursuivra jusqu'à ce que le joueur ou COM gagne.
Le contenu du traitement est affiché sur la console et le contenu affiché sur la console est également sorti dans le fichier journal.
Java est un langage développé par la société informatique américaine autrefois existante ** Sun Microsystems (maintenant Oracle America) **. Depuis que JDK 1.0 a été annoncé en janvier 1996, il a été continuellement mis à jour et Java SE 14 annoncé en mars 2020 sera la dernière version.
En retraçant l'origine du langage, il semble que le développement ait commencé à l'origine comme un langage embarqué pour les appareils électroménagers basé sur C ++. Cependant, au milieu du développement, l'objectif de l'incorporation est passé des appareils ménagers aux PDA, et il est également devenu un langage pour le développement Web. Peut-être en raison de ces divers domaines, il est devenu un langage extrêmement polyvalent utilisé dans un large éventail d'industries aujourd'hui. Si vous le connaissez, il est également utilisé dans le développement d'applications Android. ~~ Kotlin "(Plus à l'ère de Java Paisen)" ~~
Java a acquis une fiabilité élevée grâce à son expérience sur le front depuis plus de 20 ans, mais en raison de la montée en puissance du langage JVM et ~~ La méthode d'annonce d'Oracle était mauvaise ~~ "Payé de Java SE 11" Il est indéniable que la popularité du produit a été refroidie par le malentendu généralisé que cela sera fait!?
Cependant, la demande est toujours l'une des plus élevées dans toutes les langues, et même si les options pour les nouveaux projets de développement sont supprimées, les projets de maintenance et de réparation du système écrits en Java resteront, nous continuerons donc à le faire à l'avenir. Il ne fait aucun doute qu'il continuera à être utilisé pendant des décennies.
Pour créer un environnement de développement Java, utilisez un package appelé ** JDK (Java Development Kit) , qui est un ensemble de programmes requis pour le développement Java, ou un IDE qui inclut un JDK ( Eclipse ** et ** IntelliJ IDEA ** sont les principaux).
Dans cet article, nous expliquerons la procédure de création d'un environnement de développement en utilisant ** OpenJDK (à proprement parler, série OpenJDK 14x) **, qui est l'un des JDK annoncés par diverses organisations.
** * Ceci est un commentaire pour la version Windows 10 64 bits. Nous n'avons pas confirmé l'opération dans d'autres environnements. ** **
Commençons par télécharger OpenJDK. Accédez au site qui gère OpenJDK.
Dans le bloc sous l'en-tête ** Télécharger ** au centre du site, il y a un lien pour accéder à la page de téléchargement de la série OpenJDK 14x. Cliquez sur le lien pour accéder à la page cible.
Près du centre de la page de téléchargement, il y a un lien de téléchargement pour le JDK correspondant à chaque système d'exploitation, Linux, macOS et Windows. Cliquez sur le lien JDK pour Windows pour démarrer le téléchargement. J'ai pu télécharger le putain de petit poisson Wi-Fi chez moi en environ 1 minute, donc s'il s'agit d'un Wi-Fi de niveau moyen ou filaire, il devrait être terminé immédiatement.
Le fichier téléchargé doit être compressé au format .zip, alors décompressez-le. Le répertoire décompressé doit avoir un répertoire avec un nom comme ** jdk-14.0.1 **. Il s'agit du corps principal d'OpenJDK, qui contient le compilateur Java et ainsi de suite.
Dans les travaux de construction de l'environnement de développement dans d'autres langages de programmation, il peut être nécessaire de lancer le programme d'installation, etc. à partir d'ici et de procéder à la construction de l'environnement de développement, mais en Java, c'est la fin pour le moment.
Vérifiez si OpenJDK a été téléchargé et décompressé correctement.
Tout d'abord, placez le corps principal d'OpenJDK (un répertoire nommé ** jdk-14.0.1 **) directement sous le lecteur C.
Ensuite, assurez-vous que les répertoires ** bin ** stockés dans ce répertoire contiennent les fichiers exécutables ** java.exe ** et ** javac.exe **. Le premier est une application pour exécuter des programmes écrits en Java, et le second est un compilateur Java.
Pour vérifier l'opération, lancez un shell tel que l'invite de commandes ou PowerShell et tapez la commande comme indiqué ci-dessous. C'est OK lorsque ce qui suit est affiché.
S'il est affiché comme ça, c'est 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>
Vous pouvez développer Java dans l'état ci-dessus, mais mettons Path dans le répertoire ** bin ** ci-dessus pour qu'il soit facile à développer.
C'est parfait si vous pouvez le faire. Je vous remercie pour votre travail acharné.
En ce qui concerne la grammaire de base, veuillez lire le code source à la fin de l'article, et notez les choses qui ne peuvent pas être lues à partir du code source et les choses à connaître.
L'extension est **. Java **.
Si vous créez l'environnement de développement selon la procédure décrite dans cet article (elle semble être différente pour chaque environnement de développement), le code de caractère standard sera ** MS932 **. MS932 est une extension de ** Shift JIS ** avec un code de caractère également appelé ** windows-31j **. Après tout, si le code source n'inclut pas le japonais, vous pouvez l'écrire en Shift JIS ou UTF-8, et si le code source contient du japonais, vous pouvez l'écrire en Shift JIS.
Si vous souhaitez connaître le code de caractère standard de votre environnement, veuillez exécuter le programme suivant.
Test.java
class Test {
public static void main(String[] args) {
System.out.println(System.getProperty("file.encoding"));
}
}
Au fait (c'est le cas avec moi), je pense qu'il y a pas mal de gens qui veulent inclure le japonais dans le fichier source, mais qui veulent écrire le code de caractère en UTF-8. Le compilateur Java vous permet de spécifier le code de caractère au moment de la compilation, reportez-vous donc à la commande suivante.
UTF-Compilez avec 8
C:\Users\AGadget> javac .\Test.java -encoding UTF-8
Il semble que les normes de codage Java aient été annoncées par diverses organisations.
Ne vaut-il pas mieux se référer à l'une des normes de codage?
Cette section décrit la procédure de la compilation à l'exécution.
Tout d'abord, préparez le fichier source. En Java, il semble être une manière de codage de stocker une classe dans un fichier et de faire correspondre le nom du fichier avec le nom de la classe (Remarque: d'après les recherches de l'affiche). Les exemples de fichiers ci-dessous suivent ceci.
Test.java
class Test {
public static void main(String[] args) {
System.out.println("Hello world.");
}
}
Une fois le fichier source prêt, compilez-le pour générer un fichier intermédiaire (fichier .class).
compiler
C:\Users\AGadget> javac .\Test.java
C:\Users\AGadget>
Vous devriez maintenant avoir un fichier intermédiaire appelé ** Test.class **. Exécutez ceci avec java.exe.
Courir
C:\Users\AGadget> java Test
Hello world.
C:\Users\AGadget>
La procédure de compilation et d'exécution de Java est un peu compliquée, veuillez donc vous référer à un autre article de commentaire si nécessaire.
Dans l'environnement de développement créé par la procédure décrite dans cet article, le code de caractère standard du compilateur est ** Shift JIS **. Si vous souhaitez compiler avec n'importe quel code de caractère, appuyez sur la commande comme suit.
UTF-Compilez avec 8
C:\Users\AGadget> javac .\Test.javaa -encoding UTF-8
C:\Users\AGadget>
Les points d'entrée Java sont les méthodes suivantes.
public static void main(String[] args) {
//C'est le point d'entrée
}
En règle générale, changer le format ci-dessus - par exemple, changer ** public ** en ** privé ** ou changer le nom de la méthode de ** main ** à ** Main ** servira de point d'entrée. Veuillez noter qu'il ne sera pas reconnu.
Contrairement aux langages qui utilisent des classes dans n'importe quel langage ou aux langages qui n'ont pas de classes en premier lieu, Java exige que tous les traitements soient stockés dans l'une des classes. Cela s'applique également à la méthode main, qui est le point d'entrée de Java, et nous devons définir une classe pour stocker la méthode principale.
Main.java
/**
*Classe principale contenant la méthode principale
*/
class Main {
/**
*Méthode principale
*/
public static void main(String[] args) {
System.out.println("Hello world.");
}
}
En passant, c'était l'une des spécifications déroutantes lorsque j'ai touché Java pour la première fois. Jusque-là, je n'avais touché que C / JavaScript, donc cette spécification me semblait assez étrange. ~~ Pour être honnête, je n'y suis toujours pas habitué. ~~
En Java, l'opérateur ** == ** est utilisé pour comparer et déterminer si les références sont égales, et la méthode ** equals ** est utilisée pour comparer et déterminer si les valeurs sont identiques.
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()));
}
}
Essayez de courir
C:\Users\AGadget> javac .\Test.java
C:\Users\AGadget> java Test
false
true
C:\Users\AGadget>
Voir l'exemple ci-dessous.
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 est orienté";
}
if (OS.equals("iOS")) {
return "iOS est orienté";
}
if (OS.equals("BlackBerry")) {
return "BlackBerry est l'orientation";
}
System.out.println("[Error]Winmo est NG. . . ");
System.exit(0);
}
}
À première vue, ce programme semble compiler sans aucun problème, mais il est en fait joué comme une erreur de syntaxe.
C:\Users\AGadget> javac .\Test.java
.\Test.java:19:Erreur:Aucune déclaration de retour spécifiée
}
^
1 erreur
C:\Users\AGadget>
En Java, il semble que l'instruction return doit être écrite avec ** toutes les branches possibles ** lorsque la méthode renvoie une valeur de retour.
Vous pouvez le compiler en le modifiant comme suit.
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 est orienté";
}
if (OS.equals("iOS")) {
return "iOS est orienté";
}
if (OS.equals("BlackBerry OS")) {
return "BlackBerry OS est l'orientation";
}
System.out.println("[Error]Winmo est NG. . . ");
System.exit(0);
return ""; //Mis en œuvre car il est syntaxiquement nécessaire
}
}
Main.java
import java.util.Scanner;
/**
*C'est la classe principale du jeu Janken (like).
* @author AGadget
*/
class Main {
/**
*C'est la méthode principale
*/
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();
}
/**
*Une méthode qui crée et renvoie un message qui représente l'action sélectionnée par les deux personnages du jeu.
* @param action1 Il s'agit de l'action sélectionnée par le personnage de jeu 1.
* @param action2 Il s'agit de l'action sélectionnée par le personnage de jeu 2.
* @message de retour
*/
private static String generateChoicedActionMessage(String action1, String action2) {
return "> " + action1 + " vs " + action2;
}
/**
*Une méthode qui crée et renvoie un message qui représente le résultat du jeu
* @param canGame1 Indique si le personnage de jeu 1 peut continuer le jeu
* @param canGame2 Indiquer que le personnage de jeu 2 peut continuer le jeu
* @param name1 Le nom du personnage de jeu 1
* @param name2 Le nom du personnage de jeu 2
* @message de retour
*/
private static String generateGameResultMessage(boolean canGame1, boolean canGame2, String name1, String name2) {
if (canGame1 && !canGame2) {
return "> " + name1 + "C’est une victoire!";
}
if (!canGame1 && canGame2) {
return "> " + name2 + "C’est une victoire!";
}
System.out.println("[Error]Un match nul a eu lieu");
System.exit(0);
return ""; //J'écris une déclaration de retour qui n'est pas nécessaire pour le traitement car elle provoque une erreur grammaticale
}
/**
*Une méthode qui arrête le traitement jusqu'à ce que la touche Entrée soit enfoncée.
*/
private static void pause() {
System.out.print("appuyez sur Entrée. . . ");
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;
/**
*Une classe qui gère toutes les entrées et sorties vers et depuis le fichier journal de la console.
*Adopte le modèle de conception Singleton
* @author AGadget
*/
class StandardIO {
private static StandardIO instanceStandardIO = new StandardIO(); //C'est une instance de cet objet
private String logFilePath; //Chemin du fichier journal
/**
*C'est un constructeur
*À l'aide de l'objet Calendrier, le nom du fichier journal est créé à partir de la date et de l'heure actuelles
*/
private StandardIO() {
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyMMddHHmmss");
this.logFilePath = "log_" + simpleDateFormat.format(calendar.getTime()) + ".txt";
}
/**
*Une méthode qui renvoie une instance de cet objet
*Cette méthode est requise car elle utilise le modèle de conception Singleton.
* @return Une instance de cet objet
*/
public static StandardIO getInstance() {
return instanceStandardIO;
}
/**
*Méthode qui génère la chaîne de caractères spécifiée dans l'argument vers la console et le fichier journal.
*Un caractère de saut de ligne est ajouté à la fin de la valeur de sortie
* @param message Chaîne de caractères de sortie
*/
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();
}
}
/**
*Méthode qui génère un nombre arbitraire de lignes vides vers la console et le fichier journal.
*Le nombre de lignes peut être spécifié par un argument
* @param numberOfEmptyLine
*/
void printlnEmptyLine(int numberOfEmptyLine) {
for (int i = 0; i < numberOfEmptyLine; i += 1) {
this.println("");
}
}
/**
*Méthode qui génère la chaîne de caractères spécifiée dans l'argument vers la console et le fichier journal.
*Il n'y a pas de caractère de saut de ligne à la fin de la valeur de sortie
* @param message Chaîne de caractères de sortie
*/
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();
}
}
/**
*Une méthode qui accepte l'entrée standard, sort la valeur d'entrée dans un fichier journal et la renvoie à l'appelant.
* @retour Valeur d'entrée standard
*/
String readLine() {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
this.printlnOnlyToLogFile(input);
return input;
}
/**
*Cette méthode renvoie la chaîne de caractères spécifiée dans l'argument «uniquement» dans le fichier journal.
*→ Il est censé être utilisé comme un ensemble avec la méthode en charge du traitement d'entrée standard
*Un caractère de saut de ligne est ajouté à la fin de la valeur de sortie
* @param message Chaîne de caractères de sortie
*/
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
/**
*Une classe abstraite qui représente un personnage de jeu
* @author AGadget
*/
abstract class GameCharacter {
protected StandardIO standardIO = StandardIO.getInstance(); //L'objet responsable du traitement des sorties
private final int MAX_LIFE = 5; //C'est la limite supérieure de la force physique commune à tous les personnages du jeu.
private int life; //C'est la force physique
private String name; //Est le nom
protected final String[] ACTIONS = {"Goo", "Choki", "Par"}; //Liste des actions pouvant être sélectionnées
protected String action; //L'action du choix
/**
*Une méthode abstraite pour sélectionner une action
*Implémentez le processus de sélection d'une action d'une manière ou d'une autre et d'attribution de l'action sélectionnée au champ contenant l'action sélectionnée.
*/
abstract void choiceAction();
/**
*C'est un constructeur
* @param initialLife Force physique au début de la partie
* @param name Le nom du personnage du jeu
*/
GameCharacter(int initialLife, String name) {
if (initialLife < 0 && initialLife > this.MAX_LIFE ? true : false) {
System.out.println("[Error]La valeur initiale au début du jeu est invalide (" + initialLife + "）");
System.exit(0);
}
this.life = initialLife;
this.name = name;
}
/**
*C'est une méthode pour répondre si le jeu peut être continué
* @return Renvoie vrai si possible
*/
boolean canGame() {
return this.life > 0 ? true : false;
}
/**
*Une méthode qui renvoie la largeur du nom
* String.length()Contrairement à la valeur qui peut être obtenue par, etc., la valeur comptée avec des caractères demi-largeur comme 1 et des caractères pleine largeur comme 2 est renvoyée.
*/
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;
}
/**
*Une méthode qui renvoie un message sur son propre état
*Le message se compose d'une partie de nom et d'une partie de force physique
*→ Assurez-vous que la partie du nom a la même longueur et la même largeur que le nom de l'autre partie.
*→ La partie de la force physique est exprimée comme une jauge de force physique à l'aide de symboles.
* @param adversentNameWidth La largeur du nom de l'adversaire (une valeur spéciale comptée comme 1 pour les caractères demi-largeur et 2 pour les caractères pleine largeur)
*/
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());
}
/**
*Une méthode qui renvoie l'action sélectionnée
* @retour L'action sélectionnée
*/
String getAction() {
return this.action;
}
/**
*C'est une méthode qui gère les dommages
*Vérifiez si des dommages se produiront à cause de la combinaison de vos propres actions et des actions de l'adversaire, et si des dommages se produisent, réduisez votre force physique
* @param adversentAction L'action de l'adversaire
*/
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;
}
}
/**
*Une méthode qui renvoie un nom
* @nom de retour
*/
String getName() {
return this.name;
}
}
Player.java
/**
*Une classe qui représente un joueur
* @author AGadget
*/
class Player extends GameCharacter {
/**
*C'est un constructeur
* @param initialLife Force physique au début de la partie
* @param name Le nom du personnage du jeu
*/
Player(int initialLife, String name) {
super(initialLife, name);
}
/**
*Une méthode pour sélectionner une action
*Puisqu'il s'agit d'un processus pour les joueurs, nous avons mis en place un processus qui utilise une entrée standard.
*/
@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(">Entrée illégale");
standardIO.println(">Veuillez saisir à nouveau");
standardIO.printlnEmptyLine(1);
}
}
}
/**
*Méthode qui crée et renvoie les invites requises pour le traitement de la sélection d'action.
* @return Chaîne d'invite
*/
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;
/**
*Une classe qui représente COM
* @author AGadget
*/
class COM extends GameCharacter {
/**
*C'est un constructeur
* @param initialLife Force physique au début de la partie
* @param name Le nom du personnage du jeu
*/
COM(int initialLife, String name) {
super(initialLife, name);
}
/**
*Une méthode pour sélectionner une action
*Puisqu'il s'agit d'un processus pour COM, nous avons implémenté un processus qui utilise des nombres aléatoires.
*/
@Override
void choiceAction() {
Random random = new Random();
this.action = ACTIONS[random.nextInt(ACTIONS.length)];
}
}
TurnCount.java
/**
*Une classe qui représente le nombre de tours
* @author AGadget
*/
class TurnCount {
private StandardIO standardIO = StandardIO.getInstance(); //L'objet responsable du traitement des sorties
private int turnCount; //Le nombre de tours
/**
*C'est un constructeur
*/
TurnCount() {
turnCount = 0;
}
/**
*C'est une méthode pour avancer le décompte du nombre de tours
*/
void countUp() {
this.turnCount += 1;
}
/**
*Une méthode qui génère le nombre actuel de tours sous forme de message
*/
void printTurnCountMessage() {
standardIO.println("[Non." + this.turnCount + "tour】");
}
}
Recommended Posts