Questions d'entretiens chez Java Flow Control (+ Réponses)
1. introduction
Les instructions de flux de contrôle permettent aux développeurs d’utiliser la prise de décision, la création de boucles et la création de branches pour modifier de manière conditionnelle 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 mettrons en œuvre des exemples pour mieux comprendre leurs réponses.
2. Des questions
Q1. Décrivez les instructionsif-then etif-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'instructionif-then-else fournit un chemin secondaire d'exécution dans le cas où la clause if est évaluée àfalse:
if (age >= 21) {
// ...
} else {
// ...
}Contrairement aux autres langages de programmation, Java ne prend en charge que les expressionsboolean comme conditions. Si nous essayons d'utiliser un autre type d'expression, nous obtiendrons une erreur de compilation.
Q2. Décrivez l'instructionswitch. Quels types d'objets peuvent être utilisés dans la clauseswitch?
Switch permet de sélectionner plusieurs chemins d’exécution en fonction d’une valeur de variable.
Chaque chemin est étiqueté aveccase oudefault, l'instructionswitch évalue chaque expressioncase pour une correspondance et exécute toutes les instructions qui suivent l'étiquette correspondante jusqu'à unbreakL'instruction s est trouvée. S'il ne trouve pas de correspondance, le blocdefault 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 utiliserbyte,short,char,int, leurs versions encapsulées,enums etStrings comme valeursswitch.
Q3. Que se passe-t-il lorsque nous oublions de mettre une instructionbreak dans une clausecase d'unswitch?
L'instructionswitch tombe au creux. Cela signifie qu'il continuera l'exécution de toutes les étiquettescase jusqu'à ce que if trouve une instructionbreak, même si ces étiquettes ne correspondent pas à la valeur de l'expression.
Voici un exemple pour illustrer 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,number 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 unswitch plutôt qu'une instructionif-then-else et vice versa?
Une instructionswitch 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 instructionif-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 etdo-while.
Une bouclefor fournit un moyen d'itérer sur une plage de valeurs. Il est particulièrement utile de savoir à l’avance combien de fois une tâche va être répétée:
for (int i = 0; i < 10; i++) {
// ...
}Une bouclewhile peut exécuter un bloc d'instructions alors qu'une condition particulière esttrue:
while (iterator.hasNext()) {
// ...
}Undo-while est une variation d'une instructionwhile dans laquelle l'évaluation de l'expressionboolean est au bas de la boucle. Cela garantit que le code sera exécuté au moins une fois:
do {
// ...
} while (choice != -1);Q6. Qu'est-ce qu'une boucleenhanced for?
Est une autre syntaxe de l'instructionfor 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'interfaceIterable:
for (String aString : arrayOfStrings) {
// ...
}Q7. Comment sortir de façon anticipée d'une boucle?
En utilisant l'instructionbreak, nous pouvons terminer l'exécution d'une boucle immédiatement:
for (int i = 0; ; i++) {
if (i > 10) {
break;
}
}Q8. Quelle est la différence entre une instructionbreak non étiquetée et étiquetée?
Une instructionbreak sans étiquette termine l'instructionswitch,for,while oudo-while la plus interne, alors qu'une instructionbreak déclaration.
Créons un exemple pour illustrer 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;
}
}
}Lorsque le nombre 37 est trouvé, l'instruction étiquetéebreak met fin à la bouclefor la plus à l'extérieur et aucun autre cycle n'est exécuté. Ainsi,loopCycles se termine par la valeur 5.
Cependant, lesbreak non étiquetés ne terminent que l'instruction la plus interne, renvoyant le flux de contrôle vers lesfor les plus à l'extérieur qui continuent la boucle jusqu'auxrow suivants dans la variabletable, faisant lesloopCycles se terminent par une valeur de 8.
Q9. Quelle est la différence entre une instructioncontinue non étiquetée et étiquetée?
Une instructioncontinue sans étiquette passe à la fin de l'itération en cours dans la bouclefor,while oudo-while la plus interne, tandis qu'une instructioncontinue boucle extérieure marquée de l'étiquette donnée.
Voici un exemple qui le démontre:
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;
}
}
}Le raisonnement est le même que dans la question précédente. L'instructioncontinue étiquetée termine la bouclefor la plus externe.
Ainsi,loopCycles finit par contenir la valeur 5, tandis que la version sans étiquette ne termine que l'instruction la plus interne, ce qui fait que lesloopCycles se terminent par la valeur 9.
Q10. Décrivez le flux d'exécution dans une constructiontry-catch-finally.
Lorsqu'un programme est entré dans le bloctry et qu'une exception est levée à l'intérieur, l'exécution du bloctry est interrompue et le flux de contrôle continue avec un bloccatch qui peut gérer l'exception levée.
Si ce type de bloc n'existe pas, l'exécution de la méthode en cours s'arrête et l'exception est renvoyée vers la méthode précédente de la pile d'appels. Sinon, si aucune exception ne se produit, tous les blocscatch sont ignorés et l'exécution du programme se poursuit normalement.
Un blocfinally est toujours exécuté, qu'une exception ait été lancée ou non dans le corps du bloctry.
Q11. Dans quelles situations le blocfinally peut ne pas être exécuté?
Lorsque la JVM est arrêtée lors de l'exécution des blocstry oucatch, par exemple en appelantSystem.exit(), ou lorsque le thread en cours d'exécution est interrompu ou tué, le bloc finally n'est pas exécuté.
Q12. Quel est le résultat de l'exécution du code suivant?
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());Le code affiche le nombre 3. Même si le blocfinally est toujours exécuté, cela se produit uniquement après la sortie du bloctry.
Dans l'exemple, l'instructionreturn est exécutée avant la fin du bloctry-catch. Ainsi, l'affectation ànumber dans le blocfinally n'a aucun effet, puisque la variable est déjà renvoyée au code appelant de la méthodetestAssignment.
Q13. Dans quelles situations le bloctry-finally peut être utilisé même lorsque des exceptions peuvent ne pas être levées?
Ce bloc est utile lorsque nous voulons nous assurer que nous ne contournons pas accidentellement le nettoyage des ressources utilisées dans le code en rencontrant une instructionbreak,continue oureturn:
HeavyProcess heavyProcess = new HeavyProcess();
try {
// ...
return heavyProcess.heavyTask();
} finally {
heavyProcess.doCleanUp();
}De plus, nous pouvons être confrontés à des situations dans lesquelles nous ne pouvons pas gérer localement l'exception levée, ou nous voulons que la méthode actuelle lève toujours l'exception tout en nous permettant de libérer des ressources:
public void doDangerousTask(Task task) throws ComplicatedException {
try {
// ...
task.gatherResources();
if (task.isComplicated()) {
throw new ComplicatedException("Too difficult");
}
// ...
} finally {
task.freeResources();
}
}Q14. Comment fonctionnetry-with-resources?
L'instructiontry-with-resources déclare et initialise une ou plusieurs ressources avant d'exécuter le bloctry et les ferme automatiquement à la fin de l'instruction, que le bloc se soit terminé normalement ou brusquement. Tout objet implémentant les interfacesAutoCloseable ouCloseable peut être utilisé comme ressource:
try (StringWriter writer = new StringWriter()) {
writer.write("Hello world!");
}3. Conclusion
Dans cet article, nous avons abordé certaines des questions les plus fréquemment posées dans les entretiens techniques avec les développeurs Java concernant les instructions de flux de contrôle. Cela ne devrait être considéré que comme le début de recherches ultérieures et non comme une liste exhaustive.
Bonne chance dans votre interview.