Java ne tout, alors que

Question

quel comportement puis-je attendre quand je lance ce code:

do while(testA) {

    // do stuff

} while(testB);

Est-ce qu'il se comporte comme:

do {
    while(testA) {
        // do stuff
    }    
} while(testB);

Ou:

if(testA) {
    do {
        // do stuff
    } while(testA && testB);
}

Ou quelque chose de totalement inattendu?

Je pose cette question parce que je pense que cela est tout à fait ambiguë, et pour d'autres personnes à la recherche sur ce sujet, pas parce que je suis paresseux pour le tester.

Answer 1

Il est équivalent à votre premier bloc:

do {
    while(testA) {
        // do stuff
    }    
} while(testB);

Les parties pertinentes du Java grammaire lors de l'analyse ce sont:

DoStatement:
    do Statement while ( Expression ) ;

Statement:
    WhileStatement

WhileStatement:
    while ( Expression ) Statement

Statement:
    Block

Block:
    { BlockStatements_opt }

Vous pouvez voir que le compilateur Java va analyser cela comme do <WhileStatement> while ( Expression ) ;. C'est la seule façon valable pour analyser le code que vous avez écrit.

Gardez à l'esprit qu'il n'a pas de règle spéciale pour analyser cette construction. Il finit juste par être source de confusion pour un être humain à lire en raison de la façon inhabituelle la boucle do-while est écrit. En usage normal do-while est toujours écrit do { ... } while avec des accolades explicites.

Answer 2

Il fonctionne en effet, mais le comportement dépend de quelles conditions vous êtes test. Par exemple. ce code:

  int i = 2;
  int j = 4;
  do while(j > 0) {
       i--; j--;
       System.out.println("i:" + i + " j:" + j);
 } while(i > 0);

sorties:

i:1 j:3
i:0 j:2
i:-1 j:1
i:-2 j:0

Il fonctionne comme:

while(j>0) {

}

---

considérant que, par l'échange des noms de variables:

do while(i > 0) {
    //.. same as above
 } while(j > 0);

La sortie est la suivante:

i:1 j:3
i:0 j:2

On dirait qu'il se comporte comme dans le premier cas (à savoir le premier tout est considéré), mais ici, l'application ne se terminant pas!

---

Résumé: Au moment où testA est non satisfait et plus testB est ne se satisfait pas , le code fonctionne comme une boucle de while(testA){} normale.
Mais: Si, au moment où testA est ne satisfait , testB est toujours satisfait , la boucle est pas exécuté plus et le script est ne se terminant pas . Cela vaut seulement si la condition de la boucle « externe » doit être changé dans la boucle.

Mise à jour: Et après avoir lu autre réponse, je me rends compte que c'est exactement le comportement du do-while imbriquée -. Boucle while
Quoi qu'il en soit, ACQUIS: Ne pas utiliser ce type de syntaxe, car il peut vous confondre;)

Answer 3

Il se comporte comme

do {
    while(testA) { 
        // stuff
    }
} while(testB);

Alors, ce bloc de code est analysé ainsi:

{faire un bloc de code} tout TESTB est vrai. Où {un bloc de code} est le tout intérieur.

Il est certainement un peu rare d'écrire du code comme ça:)

Answer 4

La réponse est # 1. Il continuera à boucle tant que testB est satisfait, mais il ne sera pas exécuter le code si testA est pas satisfait.

Answer 5

"do {} while();" est une construction, alors que "while(){}" est une autre.

Il n'y a pas une telle chose comme « do while »; vous les imbriquant, par inadvertance, et en profitant du fait que {} est facultative pour les instructions simples.

En d'autres termes, il est syntaxiquement légal:

do System.out.println("Hello World") while (true);

Et comme dans les déclarations de if, un bloc est traité comme une seule instruction.

Quel est-à-dire votre première réponse possible est celle de droite, où « while(){} » est la seule chose non placé entre crochets à l'intérieur du « do {} while(); » externe

Answer 6

Je ne pense pas que ce code est légal.

do while(testA) {

        // do stuff

    } while(testB);