J'ai fait un jeu sur console Othello en langage C il y a quelque temps, donc Quand j'ai essayé de le faire avec Java Je me suis demandé si system ("cls"); made in C pouvait être fait en Java, mais J'ai eu beaucoup de problèmes, alors je vais l'écrire ici.
Il semble y avoir plusieurs façons, Il y avait beaucoup de choses déroutantes comme des erreurs et des avertissements. Parmi eux, je présenterai celui qui a pu être mis en œuvre le plus facilement cette fois.
Cette fois, en faisant Othello Je voulais aussi envisager l'extensibilité lorsque je voulais contrôler la sortie de l'écran, donc Créer une classe ConsoleControl qui contrôle la sortie de l'écran de la console Il a été implémenté comme une méthode clearScreen qui efface la sortie d'écran.
Sorce Code ##
import java.io.IOException;
/**
*Classe qui contrôle la sortie de l'écran de la console
*/
public class ConsoleControl {
/**
*Méthode pour effacer la sortie de l'écran de la console
* @throws IOException
* @throws InterruptedException
*/
public void clearScreen() throws IOException, InterruptedException {
new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
}
}
Pour le moment, en appelant la méthode clearScreen dans la méthode main, J'ai pu effacer la chaîne de caractères affichée à l'invite de commande.
Je ne comprenais toujours pas pourquoi ce serait "cls" si je l'écrivais comme ça à cause de mon manque de connaissances. Après avoir étudié et rattrapé ma compréhension, j'aimerais ajouter ce montant.
2018/04/26 postscript Lorsque j'ai visité après une longue période, le nombre de vues était proche de 2000 vues au lieu de 1000 vues. En l'avalant en tant que matériel de diffusion en direct, j'ai analysé ce programme et étudié le type de traitement qu'il effectuait. Kusso, à peu près intelligent.
Tout d'abord, concernant cette classe ProccessBuilder, si vous regardez l'explication officielle,
En disant "une classe pour construire une instance de la classe Process"
En créant une instance de cette classe, il est possible de créer un environnement d'exécution pour un nouveau processus à l'aide de commandes externes.
En regardant le contenu avec Open JDK SE8,
La commande spécifiée dans l'argument du constructeur est dans la classe ProcessBuilder
Il était stocké dans une variable de type List
private List<String> command;
private File directory;
private Map<String,String> environment;
private boolean redirectErrorStream;
private Redirect[] redirects;
public ProcessBuilder(String... command) {
this.command = new ArrayList<>(command.length);
for (String arg : command)
this.command.add(arg);
}
Cette méthode a été définie comme suit. (Citation source d'Open JDK)
public ProcessBuilder inheritIO() {
Arrays.fill(redirects(), Redirect.INHERIT);
return this;
}
Cette méthode affecte simplement l'indicateur INHERIT aux redirections à l'aide de la fonction Arrays.fill. Que signifie ce drapeau INHERIT? La description officielle dit:
C'est le comportement normal de la plupart des interpréteurs de commandes (shells) du système d'exploitation.
En outre, l'explication de la méthode inheritIO est
Définissez la source d'entrée / sortie standard et la destination de sortie du sous-processus pour qu'elles soient identiques au processus Java actuel. C'est une méthode simple. La forme d'appel suivante pb.inheritIO() Il se comporte exactement de la même manière que le prochain appel. pb.redirectInput(Redirect.INHERIT) .redirectOutput(Redirect.INHERIT) .redirectError(Redirect.INHERIT) Ce comportement est équivalent à la plupart des interpréteurs de commandes du système d'exploitation et des fonctions standard de la bibliothèque C system ().
En d'autres termes, il s'est avéré que l'entrée et la sortie de programmes externes peuvent être intégrées avec l'entrée et la sortie standard de Java. Voir ici pour l'entrée / sortie standard. Eh bien, à la fin de l'explication officielle
Ce comportement est équivalent à la plupart des interpréteurs de commandes du système d'exploitation et des fonctions standard de la bibliothèque C system ().
Si vous pensez que cela fonctionne de la même manière que system (), vous pouvez expliquer le mandokusai par poi.
La source est longue, elle est donc omise. Cette méthode démarre la commande ou le fichier exécutable spécifié par ProcessBuilder. D'une manière ou d'une autre, vous pouvez deviner à partir du nom de la méthode.
La source est (ry Cette méthode oblige le thread en cours de traitement à attendre la fin du sous-processus en cours d'exécution dans un autre thread.
J'ai modifié la source précédente pour la rendre comme suit.
import java.io.IOException;
public class ConsoleControl {
private ProcessBuilder pb;
/**
*Le constructeur de la classe ConsoleControl.
*Crée un environnement pour exécuter un nouveau processus qui exécute la commande spécifiée.
* @param command Commande à exécuter
*/
public ConsoleControl(String... command) {
pb = new ProcessBuilder(command);
}
/**
*Une méthode qui efface l'écran d'invite de commande.
*/
public void cls() throws IOException, InterruptedException {
pb.inheritIO().start().waitFor();
/*
* //Commande externe spécifiée dans l'argument constructeur de ProcesserBuild
* //Converti pour exécution à l'invite de commande
* ProcessBuilder pbInheritIO = pb.inheritIO();
* //Exécuter avec une commande externe
* Process pro = pbInheritIO.start();
* //Attendez que le processus en cours d'exécution sur un autre thread soit terminé
* pro.waitFor();
*/
}
}
var cc = new ConsoleControl("cmd", "/c", "cls");
var cc = new ConsoleControl("/bin/bash", "-c", "clear");
C'est comme ça? Peut-être que l'explication est insuffisante ou mal comprise, je vous serais donc reconnaissant de bien vouloir la signaler. De plus, si vous avez du temps libre, je serais heureux si vous pouviez venir nous rendre visite pour une diffusion en direct.
fin.
Recommended Posts