Je savais quelque part que logique et: "&&" a une priorité plus élevée que logique ou: "|| ' En Java.et pendant la programmation, je les fais rarement des erreurs sur eux. Mais jusqu'à présent, je n'ai trouvé aucun indice sur la façon dont cette personne agit vraiment? Que se passerait-il si je ne connaissais pas la préséance des deux et quelle erreur ferais-je?
J'ai essayé d'écrire du code pour prouver la priorité de "&&" et "|| ' mais a échoué, par exemple: Le code ci-dessus produirait les mêmes résultats, quelle que soit la priorité de "&&" et "||", c'est-à-dire que c'est,
'faux || faux && vrai || faux 'résultats des résultats faux, peu importe la préséance. Donc, en d'autres termes, je veux une méthode ou une fonction, qui pourrait prouver la priorité de "&&" et "||', il devrait produire des Les résultats dépend de la priorité de "&&" et "||" ...
Comment cette fonction pourrait-elle être faite? Est-ce possible?
Je suppose que c'est peut-être une question difficile ou une taille dramatiquement simple ... peut être ce n'est pas un problème de Java, mais quelque chose de mathématiques ...
Dans l'ensemble, quelqu'un aide?
Merci.
9 Réponses :
Prenons votre exemple Expression:
boolExp1 = true boolExp2 = false boolExp3 = false boolExp4 = false
Je consultitais la spécification Java pour voir s'ils définissaient la priorité de l'opérateur pour Les deux sont définis comme étant défini comme étant défini comme indiqué à gauche-associatif et sans précédence de l'opérateur est défini. voir S. 15.7.3 un peu bas de l'art. 17.7 ,
I.e. Java définit: comme: && et || && s. 15.23 ,
|| s. 15.24
vrai || faux && faux || FAUX Retourne True, comme on pourrait s'attendre à partir de (vrai || (faux && faux)) || faux .
Vous ne pouvez rien prouver d'une utile d'une langue de programmation en écrivant / en cours d'exécution. Pour tout ce que vous savez, le compilateur peut être mis en œuvre afin de compiler le code d'une manière illogique, incohérente ou non déterministe.
Même si vous assumez une compilation déterministe et une exécution déterministe, la seule chose qui compilait / exécutant un exemple prouve est que cet exemple particulier présente un comportement particulier. Vous ne pouvez pas généraliser logiquement d'un exemple à un autre, car sans référence à une spécification, le compilateur est juste une boîte noire. (Votre exemple très suivant pourrait être celui qui est manipulé de manière totalement contre-intuitive.)
La bonne façon de développer une compréhension d'un langage de programmation consiste à lire la spécification de langue, à un bon manuel ou à un bon tutoriel. Combinez cela avec un code d'écriture pour confirmer votre compréhension.
Si vous comptez uniquement sur la lecture d'exemple de code et de rédaction de programmes de test, vous êtes susceptible de choisir des idées fausses et de mauvaises habitudes pouvant être douloureuses à désapprendre.
Je pense qu'un mélange de lecture de la spécification puis de tester des exemples pour vous assurer de les comprendre est un bon mélange.
@Jon - Absolument. Mais il suffit de s'appuyer sur l'expérimentation est stupide.
Ceci est compté sur tout le temps dans des lignes comme les suivantes.
Clairement, ces exemples exploseraient si la première expression n'était pas toujours évaluée et la deuxième expression non évaluée de manière conditionnelle. P>
// second expression on evaluated if text != null in both cases. String text = ?? if (text != null && text.length() > 0) if (text == null || text.length() == 0
Si serait évalué comme ceci: p> pour vérifier si tel est le cas ou non,
Vous pouvez générer toutes les combinaisons de échantillon code: p> la sortie: p> && code> n'avait pas la priorité supérieure à celle || code>, alors cette expression: A code>, b code> et c code>,
et comparer le résultat de ces deux expressions,
Pour voir s'ils sont toujours égaux ou non, c'est-à-dire: p>
a code>, b code> et c code> li>
(a || b && c) == ((a || b) && c) code> li>
ol>
true false false
true || false && false => true
(true || false) && false => false
true true false
true || true && false => true
(true || true) && false => false
J'ai aussi eu la même question, mais la réponse me donnait pratiquement.
Voici mon exemple: est équivalent à donc avec cet exemple, il est facile de voir que sous la hotte en Java le logique && a une priorité supérieure à celle de ||.
Un test simple est le suivant: Notez que cela comptait la possibilité que Malheureusement, cela ne tient malheureusement pas la priorité qui change ou la priorité basée sur l'intérieur ou à l'extérieur à l'intérieur ou à l'extérieur à l'intérieur. , ou de nombreux autres ordres de fonctionnement possibles, sans parler de cela peuvent être vaincus par des compilateurs malveillants ou cassés, des ordinateurs malveillants ou brisés et des rayons cosmiques. Quoi qu'il en soit, il est vraiment difficile de prouver votre compilateur / ordinateur / Univers ne joue pas avec vous. Alors vérifiez la spécification de la langue en plus des tests. && et || pourrait avoir une précédente égale, et ensuite, dans ce cas, détermine s'ils sont exécutés de gauche à droite, ou à droite à gauche.
Les deux && et || avoir la même précalence, l'évaluation se produit de gauche à droite. Laissez-moi vous expliquer avec un exemple.
arg1 || arg2 && arg3 || arg4
output && arg3 || arg4
output || arg4
output
public static void main(String[] args) {
boolean res = b(false,1) || b(true,2) && b(false,3) || b(false,4);
System.out.println(res);
}
static boolean b(boolean b, int i){
System.out.println(i);
return b;
}
// 1 2 3 4 false
Vous voudrez peut-être lire la spécification de langue Java. Il indique le comportement exact de tout dans un programme Java.