Demandez oui/non pour revenir à la boucle

utilisation do{..... }while();

comme:

boolean again=true;
do{
    try{
    //your code
    }
    //your code
}while(again);

Comment puis-je revenir à l'essai de la boucle si l'utilisateur répond à Y/y?

Vous ne pouvez pas revenir à try{.....} . Vous devez utiliser

public static void main(String... args){
    //your code
} 

au lieu de public static void main(String[] args){}

et pour revenir utilisation main(); à l'emplacement de votre choix de code.

Java a beaucoup d'outils pour quelque chose comme cela. Ceux-ci sont connus comme des "boucles". Les boucles disponibles dans Java sont les while, do ... while, for, et for ... each. La boucle while est la plus simple. Il ressemble à ceci:

while (condition) {
    //Some code
}

De coeur, où j'ai mis "condition" de mettre en valeur booléenne. Une valeur booléenne est une valeur qui peut être soit true ou false, rien d'autre. En Java, vous pouvez créer des variables de la boolean type, mais la plupart du temps, vous n'aurez pas explicitement de créer une valeur de type boolean.

Au lieu de cela, vous allez utiliser les instructions conditionnelles. Par exemple x < y, x == y, et x >= y sont tous des "instructions conditionnelles". Cela signifie que, en fin de compte, ils évaluent en valeur booléenne. Donc, dans ce code:

int x = 1;
int y = 5;
if (x < y) {
    //Code
}

Où il est dit x < y, c'est en fait l'évaluation en true derrière les coulisses. Les valeurs booléennes sont importants et sont utilisés dans de nombreux endroits en Java.

Bref, revenons sur le sujet de boucles, passons à la prochaine boucle, do ... while. Il ressemble à ceci:

do {
    //Code
} while (condition);

do ... while fonctionne de la même comme while, mais il est toujours exécutée au moins une fois, même si la condition est false.

for et for ... each sont un peu plus compliquées. Ils sont vraiment juste des raccourcis. Considérons le code suivant:

int i = 0;
while (i < 10) {
    System.out.println("I is: " + i);
    i++;
}

Ici, la boucle sera exécuté 10 fois, et i permettra de garder une trace de la façon dont de nombreuses boucles. Le for boucle peut faire la même chose, mais de façon plus concise:

for (int i = 0; i < 10; i++) {
    System.out.println("I is: " + i);
}

Ce code va faire la même chose que le premier, mais il utilise un for boucle. Comme vous pouvez le voir, le for boucle en trois parties. Dans la première, vous pouvez déclarer une variable, dans le second, de vous mettre une condition, et dans la troisième, vous mettez quelque chose qui est exécuté à chaque itération de la boucle. for boucles sont souvent utilisés lors de l'itération sur des tableaux, mais vous ne pouvez pas avoir appris que encore, donc ne vous inquiétez pas.

La for ... each boucle est plus complexe que tous les autres, donc si vous ne comprenez pas tout de suite, ne vous inquiétez pas. En gros, c'est un moyen rapide d'obtenir tous les éléments d'une liste, ou tout ce qui est dans les Collections de l'API. Par exemple, disons que vous avez une liste de Chaînes, vous pouvez l'utiliser pour obtenir toutes les Chaînes dans la liste:

for (String string : aList) {
    System.out.println(string);
}

Qui serait aller à travers chaque Chaîne dans la liste et de les imprimer.

Bref, revenons à notre problème. Ici, nous avons besoin de choisir une boucle à utiliser, et il semble que le meilleur pour la situation serait une simple while boucle. Juste faire quelque chose comme ceci:

boolean condition = true;
while (condition) {

    //Your code

    try {
        while (true) { //Creates an infinite loop
            in = input.readLine();
            if (in.equalsIgnoreCase("y")) {
                condition = true;
                break;
            } else if (in.equalsIgnoreCase("n")) {
                condition = false;
                break;
            } else {
                System.out.println("Please enter either Y or N.");
            }
        }
    } catch (IOException e) {
        System.out.println("ERROR!");
    }

}

Ici, nous utilisons deux while boucles. La première enveloppe l'ensemble du code, la vérification de booléenne appelée condition. Nous avons initialisé à être true, de sorte que la boucle sera toujours exécuté au moins une fois. Deuxièmement, j'ai fait un autre while boucle. Ici, je n'ai while (true), qui durera pour toujours. Toutefois, vous pouvez "pause" en dehors d'une boucle à l'aide de la break mot-clé. La raison que j'ai utilisé, l'utilisateur a la possibilité de saisir autre chose que "y" ou "n". Dans ce cas, il faut juste leur demander à nouveau. Si elle devient "Y", il définit condition à true et les pauses de la boucle (ce qui est techniquement inutile, puisque la condition est d'ores et déjà true). Si elle devient "N", il définit false et les pauses de la boucle. Puisqu'il est désormais false, la boucle sera fermé et le programme prendra fin.