QUIZ N°5 - Structures conditionnelles

QUIZ N°5 - Structures conditionnelles

Passer ce quiz

Question 1

Remplir les espaces vides:

Étant donné deux objets String non nuls avec les noms de référence obj1 et obj2, si obj1 ______ obj2 est évaluée à true, les obj1 _______ obj2 doivent également être évaluées à true.

  •   ==, equals()
  •   !=, equals()
  •   equals(), ==
  •   equals(), =!

(Option 1). Pour cette question, rappelez-vous que si deux objets String sont évalués à true avec ==, ils sont alors le même objet. S'il s'agit du même objet String, equals () renverra trivialement la valeur true. L'option 1 reflète correctement ce principe. L'option 2 est incorrecte, car deux objets String non identiques peuvent toujours être équivalents en termes equals(). Par exemple, obj1 == new String ("obj1") est évalué à false, mais equals () sera évalué à true sur ces objets String. De même, les options 3 et 4 sont également incorrectes car deux objets String équivalents en termes equals() peuvent être différents.



Question 2

Combien de 1 sont affichés lorsque le programme suivant est compilé et exécuté?

                                    package city;

                                    public class Road {
                                        public static void main(String... in) {
                                            int intersections = 100;
                                            int streets = 200;
                                            if (intersections < 150) {
                                                System.out.print("1");
                                            } else if (streets && intersections > 1000) {
                                                System.out.print("2");
                                            }
                                            if (streets < 500)
                                                System.out.print("1");
                                            else
                                                System.out.print("2");
                                        }
                                    }                                                                                                                                      
                            

  •   Aucun
  •   Un
  •   Deux
  •   Le code ne compile pas.

(Option 4). Le code ne se compile pas, faisant de l'option 4 la bonne réponse. La raison pour laquelle le code ne compile pas est due au test de la deuxième instruction if-then. L'expression (streets && intersections> 1000) n'est pas valide, car streets n'est pas une expression booléenne et ne peut pas être utilisée comme élément de gauche de l'opérateur && de la logique conjonctive.



Question 3

Quelle affirmation sur les opérateurs logiques & et && est vraie?

  •   Les opérateurs & et && sont interchangeables et produisent toujours les mêmes résultats au moment de l'exécution.
  •   L'opérateur & évalue toujours les deux opérandes, tandis que l'opérateur && ne peut qu'évaluer l'opérande gauche.
  •   Les deux expressions sont évaluées sur true si l'un des opérandes est true.
  •   L’opérateur & évalue toujours les deux opérandes, tandis que l’opérateur && peut uniquement évaluer le bon opérande.

(Option 2). Les opérateurs & et && ne sont pas interchangeables car l'opérateur conjonctif & évalue toujours les deux côtés de l'expression, tandis que l'opérateur && conjonctif conditionnel n'évalue le côté droit de l'expression que si le côté gauche est déterminé comme étant vrai. C'est pourquoi les opérateurs conditionnels sont souvent appelés opérateurs de court-circuit, ignorant l'expression de droite lors de l'exécution. Pour ces raisons, l'option 2 est la bonne réponse.



Question 4

Quelle est la sortie de l'extrait de code suivant?

                                int x = 10, y = 5;
                                boolean w = true, z = false;
                                x = w ? y++ : y--;
                                w = !z;
                                System.out.print((x+y)+" "+(w ? 5 : 10));                                                                                                                                                                       
                            

  •   Le code ne compile pas.
  •   10 10
  •   11 5
  •   12 5

(Option 3). Le code est compilé, donc l'option 1 est incorrecte. Comme w commence vrai, la troisième ligne prend le premier côté droit de l'expression ternaire, en renvoyant et en affectant 5 à x (opérateur de post-incrémentation) tout en incrémentant y à 6. Sur la quatrième ligne, la valeur de w est définie sur !z. Puisque z est faux, la valeur de w reste vraie. La dernière ligne affiche la valeur de (5 + 6) et (true? 5: 10), qui correspond à 11 5, faisant de l’Option 3 la bonne réponse.



Question 5

Lequel des éléments suivants n'est pas un résultat possible de l'exécution du programme suivant ?

                                    public class ConditionallyLogical {
                                        public static void main(String... data) {
                                            if (data.length >= 1 && (data[0].equals("meknes") || data[0].equals("rabat")) && data.length < 2) {
                                                System.out.print(data[0]);
                                            }
                                        }
                                    }                                                                                                                                                                                                       
                            

  •   Rien n'est affiché
  •   meknes est affiché.
  •   Le programme lève une exception lors de l'exécution.
  •   rabat est affiché.

(Option 3). La clé pour comprendre cette question est de se rappeler que l'opérateur de conjonction conditionnelle && n'exécute le côté droit de l'expression que si le côté gauche est vrai. Si data est un tableau vide, l'expression se termine tôt et rien n'est généré.

La deuxième partie de l’expression retournera la valeur true si le premier élément de data est meknes ou rabat. Comme nous savons d'après la première partie de la déclaration que les données ont une longueur d'au moins une, aucune exception ne sera levée. La dernière partie de l'expression avec data.length <2 ne modifie pas la sortie lorsque data est un tableau de taille un. Par conséquent, meknes et rabat sont les deux sorties possibles. Pour ces raisons, l'option 3 est le seul résultat inattendu au moment de l'exécution.



Question 6

Quelle affirmation sur l'opérateur ^ est correcte?

  •   Si l'un des opérandes de ^ est vrai, le résultat est toujours vrai.
  •   Il existe une forme conditionnelle de l'opérateur, notée ^^.
  •   Si les deux opérandes de ^ sont vrais, le résultat est vrai.
  •   L'opérateur ^ ne peut être appliqué qu'aux valeurs booléennes.

(Option 4). L'opérateur ou exclusif (XOR) ^ nécessite d'évaluer les deux opérandes pour déterminer le résultat. Pour cette raison, les options 1 et 2 sont incorrectes. Pour l'option 2, vous ne pouvez pas avoir d'opération de court-circuit si les deux opérandes sont toujours lus, par conséquent ^^ n'existe pas. L'option 3 est une instruction incorrecte, car l'opérateur ^ ne renvoie vrai que si un seul opérande est vrai. Enfin, l'option 4 est correcte car le ^ n'est appliqué qu'aux valeurs booléennes en Java.



Question 7

Remplir les espaces vides:

Une instruction switch peut avoir ______ instructions case et ______ instructions default.

  •   au plus une, au moins une
  •   un nombre quelconque de, au plus une
  •   au moins une, un nombre quelconque de
  •   au moins une, au plus une

(Option 2). En excluant toute limitation de machine virtuelle Java, une instruction switch peut comporter un nombre illimité d'instructions case (y compris aucune) mais au plus une instruction default, l'option 2 identifiant correctement cette relation.



Question 8

Remplir les espaces vides:

L'opérateur _______ est vrai si l'un des opérandes est vrai, alors que l'opérateur ______ renverse une valeur booléenne.

  •   +, -
  •   &&, !
  •   |, -
  •   ||, !

(Option 4). L'opérateur de disjonction conditionnelle || (OR)  est vrai si l'un des opérandes est vrai, alors que l'opérateur du complément logique (!) inverse ou retourne une valeur booléenne, faisant de l'option 4 la bonne réponse. Les autres options utilisent des opérateurs qui ne correspondent pas à cette description. En particulier, les options 1 et 3 incluent des opérateurs qui ne peuvent être appliqués qu'aux valeurs numériques et non aux valeurs booléennes.



Question 9

Quel est le résultat du programme suivant ?

                                    public class Baby {
                                        public static String play(int toy, int age) {
                                            final String game;
                                            if (toy < 2)
                                                game = age > 1 ? 1 : 10; // p1
                                            else
                                                game = age > 3 ? "Ball" : "Swim"; // p2
                                    
                                            return game;
                                        }
                                    
                                        public static void main(String[] variables) {
                                            System.out.print(play(5, 2));
                                        }
                                    }                                                                                                                                                                                                                                        
                            

  •   Ball
  •   Swim
  •   Le code ne se compile pas à cause de p1.
  •   Le code ne se compile pas à cause de p2.

(Option 3). Pour résoudre ce problème, il est essentiel de rappeler que le type de la valeur renvoyée par une opération ternaire est déterminé par les expressions figurant à droite. Sur la ligne p1, les expressions sont de type int, mais l’affectation correspond à la variable game, de type String. L'affectation n'étant pas valide, le code ne se compile pas et l'option 3 est correcte.



Question 10

Remplir les espaces vides :

Les opérateurs–, ________ , _________ , ______ , et % sont répertoriés dans la même ou dans un ordre croissant du niveau de priorité de l'opérateur.

  •   +, /, *
  •   --, -, *
  •   ++, /, *
  •   *, ++, %

(Option 1). Dans l'option 2, l'opérateur de soustraction vient incorrectement après l'opérateur de décrémentation. Dans l'option 3, l'opérateur de division / vient incorrectement après l'opérateur d'incrémentation ++. Dans l'option 4, l'opérateur de module % vient incorrectement après l'opérateur d'incrémentation ++. La réponse correcte est l'option 1, où les opérateurs soustraction - et addition + sont suivis par les opérateurs division / et multiplication *.



Partager ce quiz avec tes amis :