Questions d'entretien sur Java Flow Control (+ réponses)

Cet article fait partie d'une série: • Questions d'entretien sur les collections Java

• Questions d’entretien sur Java Type System

• Questions d’entretien sur Java Concurrency (+ réponses)

• Questions d'entretien sur la structure des classes Java et l'initialisation

• Questions d'entrevue Java 8 (+ réponses)

• Questions d’entrevue sur la gestion de la mémoire dans Java (+ réponses)

• Questions d'entrevue Java Generics (+ réponses)

• Questions d'entretien sur Java Flow Control (+ réponses) (article actuel) • Questions d'entretien sur Java Exceptions (+ réponses)

• Questions d'entrevue sur les annotations Java (+ réponses)

• Principales questions d'entrevue Spring Framework

1. Introduction

Les instructions de flux de contrôle permettent aux développeurs d'utiliser la prise de décision, la mise en boucle et le branchement pour modifier conditionnellement le flux d'exécution de blocs de code particuliers.

Dans cet article, nous allons passer en revue quelques questions d'entrevue de contrôle de flux qui peuvent apparaître pendant une interview et, le cas échéant; nous allons mettre en œuvre des exemples pour mieux comprendre leurs réponses.

2. Questions

Q1. Décrivez les instructions if-then et if-then-else . Quels types d'expressions peuvent être utilisés comme conditions?

Les deux instructions indiquent à notre programme d'exécuter le code qu'elles contiennent uniquement si une condition particulière est évaluée à true . Cependant, l' instruction if-then-else fournit un chemin secondaire d'exécution au cas où la clause if serait évaluée à false :

if (age >= 21) { // ... } else { // ... }

Contrairement à d'autres langages de programmation, Java ne prend en charge que les expressions booléennes comme conditions. Si nous essayons d'utiliser un type d'expression différent, nous obtiendrons une erreur de compilation.

Q2. Décrivez l' instruction switch . Quels types d'objets peuvent être utilisés dans la clause switch ?

Switch permet la sélection de plusieurs chemins d'exécution en fonction de la valeur d'une variable.

Chaque chemin est étiqueté avec case ou par défaut , l' instruction switch évalue chaque expression case pour une correspondance et exécute toutes les instructions qui suivent l'étiquette correspondante jusqu'à ce qu'une instruction break soit trouvée. S'il ne trouve pas de correspondance, le bloc par défaut sera exécuté à la place:

switch (yearsOfJavaExperience) { case 0: System.out.println("Student"); break; case 1: System.out.println("Junior"); break; case 2: System.out.println("Middle"); break; default: System.out.println("Senior"); }

Nous pouvons utiliser byte , short , char , int , leurs versions encapsulées , enum s et String s comme valeurs de commutation .

Q3. Que se passe-t-il lorsque nous oublions de mettre une instruction break dans une clause case d'un commutateur ?

L' instruction switch tombe en panne. Cela signifie qu'il continuera l'exécution de toutes les étiquettes de cas jusqu'à ce que if trouve une instruction break , même si ces étiquettes ne correspondent pas à la valeur de l'expression.

Voici un exemple pour démontrer ceci:

int operation = 2; int number = 10; switch (operation) { case 1: number = number + 10; break; case 2: number = number - 4; case 3: number = number / 3; case 4: number = number * 10; break; }

Après avoir exécuté le code, nombre contient la valeur 20, au lieu de 6. Cela peut être utile dans les situations où nous voulons associer la même action à plusieurs cas.

Q4. Quand est-il préférable d'utiliser une sorcière S plutôt qu'une déclaration I f-Then-Else et vice versa?

Une instruction switch est mieux adaptée lors du test d'une seule variable par rapport à plusieurs valeurs uniques ou lorsque plusieurs valeurs exécutent le même code:

switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 2: days = 28; break; default: days = 30; }

Une instruction if-then-else est préférable lorsque nous devons vérifier des plages de valeurs ou plusieurs conditions:

if (aPassword == null || aPassword.isEmpty()) { // empty password } else if (aPassword.length() < 8 || aPassword.equals("12345678")) { // weak password } else { // good password }

Q5. Quels types de boucles Java prend-il en charge?

Java propose trois types de boucles: for , while et do-while .

Une boucle for fournit un moyen d'itérer sur une plage de valeurs. C'est plus utile lorsque nous savons à l'avance combien de fois une tâche va être répétée:

for (int i = 0; i < 10; i++) { // ... }

A en boucle peut exécuter un bloc d'instructions alors qu'une condition particulière est vraie :

while (iterator.hasNext()) { // ... }

Un do-while est une variante d'une instruction while dans laquelle l'évaluation de l' expression booléenne est au bas de la boucle. Cela garantit que le code s'exécutera au moins une fois:

do { // ... } while (choice != -1);

Q6. Qu'est-ce qu'une boucle for améliorée ?

Est une autre syntaxe de l' instruction for conçue pour parcourir tous les éléments d'une collection, d'un tableau, d'une énumération ou de tout objet implémentant l' interface Iterable :

for (String aString : arrayOfStrings) { // ... }

Q7. Comment sortir de manière anticipée d'une boucle?

En utilisant l' instruction break , nous pouvons mettre fin immédiatement à l'exécution d'une boucle:

for (int i = 0; ; i++) { if (i > 10) { break; } }

Q8. Quelle est la différence entre une instruction break non étiquetée et une instruction break étiquetée ?

Une instruction break non étiquetée termine le commutateur le plus interne , l' instruction for , while ou do-while , tandis qu'une instruction break étiquetée termine l'exécution d'une instruction externe.

Créons un exemple pour démontrer ceci:

int[][] table = { { 1, 2, 3 }, { 25, 37, 49 }, { 55, 68, 93 } }; boolean found = false; int loopCycles = 0; outer: for (int[] rows : table) { for (int row : rows) { loopCycles++; if (row == 37) { found = true; break outer; } } }

When the number 37 is found, the labeled break statement terminates the outermost for loop, and no more cycles are executed. Thus, loopCycles ends with the value of 5.

However, the unlabeled break only ends the innermost statement, returning the flow of control to the outermost for that continues the loop to the next row in the table variable, making the loopCycles end with a value of 8.

Q9. What is the difference between an unlabeled and a labeled continue statement?

An unlabeled continue statement skips to the end of the current iteration in the innermost for, while, or do-while loop, whereas a labeled continue skips to an outer loop marked with the given label.

Here's an example that demonstrates this:

int[][] table = { { 1, 15, 3 }, { 25, 15, 49 }, { 15, 68, 93 } }; int loopCycles = 0; outer: for (int[] rows : table) { for (int row : rows) { loopCycles++; if (row == 15) { continue outer; } } }

The reasoning is the same as in the previous question. The labeled continue statement terminates the outermost for loop.

Thus, loopCycles ends holding the value 5, whereas the unlabeled version only terminates the innermost statement, making the loopCycles end with a value of 9.

Q10. Describe the execution flow inside a try-catch-finally construct.

When a program has entered the try block, and an exception is thrown inside it, the execution of the try block is interrupted, and the flow of control continues with a catch block that can handle the exception being thrown.

If no such block exists then the current method execution stops, and the exception is thrown to the previous method on the call stack. Alternatively, if no exception occurs, all catch blocks are ignored, and program execution continues normally.

A finally block is always executed whether an exception was thrown or not inside the body of the try block.

Q11. In which situations the finally block may not be executed?

When the JVM is terminated while executing the try or catch blocks, for instance, by calling System.exit(), or when the executing thread is interrupted or killed, then the finally block is not executed.

Q12. What is the result of executing the following code?

public static int assignment() { int number = 1; try { number = 3; if (true) { throw new Exception("Test Exception"); } number = 2; } catch (Exception ex) { return number; } finally { number = 4; } return number; } System.out.println(assignment());

The code outputs the number 3. Even though the finally block is always executed, this happens only after the try block exits.

In the example, the return statement is executed before the try-catch block ends. Thus, the assignment to number in the finally block makes no effect, since the variable is already returned to the calling code of the assignment method.

Q13. In which situations try-finally block might be used even when exceptions might not be thrown?

This block is useful when we want to ensure we don't accidentally bypass the clean up of resources used in the code by encountering a break, continue or return statement:

HeavyProcess heavyProcess = new HeavyProcess(); try { // ... return heavyProcess.heavyTask(); } finally { heavyProcess.doCleanUp(); }

Also, we may face situations in which we can't locally handle the exception being thrown, or we want the current method to throw the exception still while allowing us to free up resources:

public void doDangerousTask(Task task) throws ComplicatedException { try { // ... task.gatherResources(); if (task.isComplicated()) { throw new ComplicatedException("Too difficult"); } // ... } finally { task.freeResources(); } }

Q14. How does try-with-resources work?

The try-with-resources statement declares and initializes one or more resources before executing the try block and closes them automatically at the end of the statement regardless of whether the block completed normally or abruptly. Any object implementing AutoCloseable or Closeable interfaces can be used as a resource:

try (StringWriter writer = new StringWriter()) { writer.write("Hello world!"); }

3. Conclusion

Dans cet article, nous avons couvert certaines des questions les plus fréquemment posées lors des entretiens techniques pour les développeurs Java, concernant les instructions de flux de contrôle. Cela ne doit être considéré que comme le début de recherches supplémentaires et non comme une liste exhaustive.

Bonne chance dans votre entretien.

Suivant » Questions d'entrevue Java Exceptions (+ réponses) « Précédent Questions d'entrevue Java Generics (+ réponses)