Domande di intervista sul controllo del flusso Java (+ risposte)

Questo articolo fa parte di una serie: • Domande di intervista sulle raccolte Java

• Domande di intervista sul sistema di tipo Java

• Domande di intervista sulla concorrenza Java (+ risposte)

• Struttura delle classi Java e domande di colloquio sull'inizializzazione

• Domande di intervista Java 8 (+ risposte)

• Gestione della memoria in Java Intervista Domande (+ risposte)

• Domande di intervista su Java Generics (+ risposte)

• Domande di intervista sul controllo del flusso Java (+ risposte) (articolo corrente) • Domande di intervista sulle eccezioni Java (+ risposte)

• Domande di intervista sulle annotazioni Java (+ risposte)

• Domande principali per l'intervista su Spring Framework

1. Introduzione

Le istruzioni del flusso di controllo consentono agli sviluppatori di utilizzare il processo decisionale, i cicli e le ramificazioni per modificare in modo condizionale il flusso di esecuzione di particolari blocchi di codice.

In questo articolo, esamineremo alcune domande dell'intervista sul controllo del flusso che potrebbero apparire durante un'intervista e, dove appropriato; implementeremo esempi per comprendere meglio le loro risposte.

2. Domande

Q1. Descrivi le istruzioni if-then e if-then-else . Quali tipi di espressioni possono essere utilizzate come condizioni?

Entrambe le istruzioni dicono al nostro programma di eseguire il codice al loro interno solo se una particolare condizione restituisce true . Tuttavia, l' istruzione if-then-else fornisce un percorso di esecuzione secondario nel caso in cui la clausola if restituisca false :

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

A differenza di altri linguaggi di programmazione, Java supporta solo espressioni booleane come condizioni. Se proviamo a utilizzare un diverso tipo di espressione, otterremo un errore di compilazione.

Q2. Descrivi l' istruzione switch . Quali tipi di oggetti possono essere utilizzati nella clausola switch ?

Switch consente la selezione di diversi percorsi di esecuzione in base al valore di una variabile.

Ogni percorso è etichettato con case o default , l' istruzione switch valuta ogni espressione case per una corrispondenza ed esegue tutte le istruzioni che seguono l'etichetta corrispondente finché non viene trovata un'istruzione break . Se non riesce a trovare una corrispondenza, verrà invece eseguito il blocco predefinito :

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"); }

Possiamo usare byte , short , char , int , le loro versioni avvolti, enum s e String s come interruttore valori.

Q3. Cosa succede quando dimentichiamo di inserire un'istruzione break in una clausola case di uno switch ?

La dichiarazione di switch cade nel vuoto. Ciò significa che continuerà l'esecuzione di tutte le etichette dei casi fino a quando non trova un'istruzione break , anche se quelle etichette non corrispondono al valore dell'espressione.

Ecco un esempio per dimostrarlo:

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; }

Dopo aver eseguito il codice, il numero contiene il valore 20, invece di 6. Ciò può essere utile in situazioni in cui si desidera associare la stessa azione a più casi.

Q4. Quando è preferibile usare una strega S su un'affermazione I f-Then-Else e viceversa?

Un'istruzione switch è più adatta quando si verifica una singola variabile rispetto a molti valori singoli o quando diversi valori eseguiranno lo stesso codice:

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; }

Un'istruzione if-then-else è preferibile quando è necessario controllare intervalli di valori o condizioni multiple:

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

Q5. Quali tipi di loop supporta Java?

Java offre tre diversi tipi di loop: for , while e do-while .

Un ciclo for fornisce un modo per iterare su un intervallo di valori. È molto utile quando sappiamo in anticipo quante volte un'attività verrà ripetuta:

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

Un ciclo while può eseguire un blocco di istruzioni mentre una particolare condizione è vera :

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

Un do-while è una variazione di un'istruzione while in cui la valutazione dell'espressione booleana si trova alla fine del ciclo. Ciò garantisce che il codice verrà eseguito almeno una volta:

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

Q6. Cos'è un ciclo avanzato per ?

È un'altra sintassi dell'istruzione for progettata per iterare tutti gli elementi di una raccolta, array, enum o qualsiasi oggetto che implementa l' interfaccia Iterable :

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

Q7. Come puoi uscire anticipatamente da un loop?

Usando l' istruzione break , possiamo terminare immediatamente l'esecuzione di un ciclo:

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

Q8. Qual è la differenza tra un'istruzione break senza etichetta e una con etichetta ?

Un'istruzione break senza etichetta termina lo switch più interno , for , while o do-while , mentre un'istruzione break etichettata termina l'esecuzione di un'istruzione esterna.

Creiamo un esempio per dimostrarlo:

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

In questo articolo, abbiamo coperto alcune delle domande più frequenti che appaiono nelle interviste tecniche per gli sviluppatori Java, riguardanti le istruzioni del flusso di controllo. Questo dovrebbe essere considerato solo come l'inizio di ulteriori ricerche e non come un elenco esaustivo.

Buona fortuna per la tua intervista.

Successivo » Domande di intervista sulle eccezioni Java (+ Risposte) « Precedente Domande sui colloqui di Java Generics (+ Risposte)