Vragen over Java Flow Control-sollicitatiegesprekken (+ antwoorden)

Dit artikel maakt deel uit van een reeks: • Interviewvragen over Java Collections

• Vragen over het Java Type System-interview

• Vragen over Java Concurrency-sollicitatiegesprekken (+ antwoorden)

• Vragen over Java-klassenstructuur en initialisatie

• Java 8 sollicitatievragen (+ antwoorden)

• Geheugenbeheer in Java-interviewvragen (+ antwoorden)

• Java Generics sollicitatievragen (+ antwoorden)

• Java Flow Control-interviewvragen (+ antwoorden) (huidig ​​artikel) • Java-uitzonderingen interviewvragen (+ antwoorden)

• Vragen over Java-annotaties tijdens sollicitatiegesprekken (+ antwoorden)

• Topvragen tijdens het Spring Framework-interview

1. Inleiding

Met controlestroomverklaringen kunnen ontwikkelaars besluitvorming, looping en branching gebruiken om de uitvoeringsstroom van bepaalde codeblokken voorwaardelijk te wijzigen.

In dit artikel bespreken we enkele vragen over flow control-interviews die tijdens een interview naar voren kunnen komen en, waar van toepassing; we zullen voorbeelden implementeren om hun antwoorden beter te begrijpen.

2. Vragen

V1. Beschrijf de als dan en als dan anders verklaringen. Welke soorten uitdrukkingen kunnen als voorwaarden worden gebruikt?

Beide instructies vertellen ons programma om de code erin alleen uit te voeren als een bepaalde voorwaarde evalueert naar waar. echter, de als dan anders instructie biedt een secundair uitvoeringspad voor het geval de if-clausule evalueert naar false:

if (leeftijd> = 21) {// ...} anders {// ...}

In tegenstelling tot andere programmeertalen ondersteunt Java alleen boolean uitdrukkingen als voorwaarden. Als we een ander type uitdrukking proberen te gebruiken, krijgen we een compilatiefout.

Q2. Beschrijf de schakelaar uitspraak. Welke objecttypen kunnen worden gebruikt in het schakelaar clausule?

Switch maakt het mogelijk om verschillende uitvoeringspaden te selecteren op basis van de waarde van een variabelen.

Elk pad is gelabeld met geval of standaard, de schakelaar statement evalueert elk geval expressie voor een overeenkomst en voert alle instructies uit die volgen op het overeenkomende label tot een breken verklaring is gevonden. Als het geen overeenkomst kan vinden, kan het standaard blok wordt in plaats daarvan uitgevoerd:

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

We kunnen gebruiken byte, kort, char, int, hun ingepakte versies, opsommings en Draads als schakelaar waarden.

Q3. Wat gebeurt er als we vergeten een breken verklaring in een geval clausule van een schakelaar?

De schakelaar verklaring valt door. Dit betekent dat het de uitvoering van alles zal voortzetten geval labels tot if vindt een breken statement, ook al komen die labels niet overeen met de waarde van de expressie.

Hier is een voorbeeld om dit te demonstreren:

int operatie = 2; int nummer = 10; schakelaar (bediening) {geval 1: nummer = nummer + 10; breken; geval 2: nummer = nummer - 4; geval 3: nummer = nummer / 3; geval 4: nummer = nummer * 10; breken; }

Na het uitvoeren van de code, aantal heeft de waarde 20 in plaats van 6. Dit kan handig zijn in situaties waarin we dezelfde actie aan meerdere gevallen willen koppelen.

V4. Wanneer heeft het de voorkeur om een ​​S te gebruikenheks Over een ikf-dan-anders Statement en vice versa?

EEN schakelaar -instructie is beter geschikt bij het testen van een enkele variabele tegen veel enkele waarden of wanneer verschillende waarden dezelfde code zullen uitvoeren:

switch (maand) {case 1: case 3: case 5: case 7: case 8: case 10: case 12: dagen = 31; breken; geval 2: dagen = 28; breken; standaard: dagen = 30; }

Een als dan anders instructie verdient de voorkeur wanneer we waardenbereiken of meerdere voorwaarden moeten controleren:

if (aPassword == null || aPassword.isEmpty ()) {// leeg wachtwoord} else if (aPassword.length () <8 || aPassword.equals ("12345678")) {// zwak wachtwoord} else {/ / goed wachtwoord}

V5. Welke soorten loops ondersteunt Java?

Java biedt drie verschillende soorten loops: voor, terwijl, en doen terwijl.

EEN voor loop biedt een manier om een ​​reeks waarden te herhalen. Het is vooral handig als we van tevoren weten hoe vaak een taak zal worden herhaald:

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

EEN terwijl loop kan een blok met instructies uitvoeren terwijl een bepaalde voorwaarde dat is waar:

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

EEN doen terwijl is een variatie op een terwijl verklaring waarin de evaluatie van de boolean expressie staat onderaan de lus. Dit garandeert dat de code minstens één keer wordt uitgevoerd:

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

V6. Wat is een verbeterd voor lus?

Is een andere syntaxis van de voor -instructie die is ontworpen om alle elementen van een verzameling, array, opsomming of een willekeurig object te doorlopen dat de Herhaalbaar koppel:

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

V7. Hoe kun je verwacht een lus verlaten?

De ... gebruiken breken statement, kunnen we de uitvoering van een lus onmiddellijk beëindigen:

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

V8. Wat is het verschil tussen een ongelabeld en een gelabeld breken uitspraak?

Een ongelabeld breken statement beëindigt het binnenste schakelaar, voor, terwijl of doen terwijl statement, terwijl een gelabeld breken beëindigt de uitvoering van een uiterlijke verklaring.

Laten we een voorbeeld maken om dit te demonstreren:

int [] [] table = {{1, 2, 3}, {25, 37, 49}, {55, 68, 93}}; boolean gevonden = false; int loopCycles = 0; buitenste: voor (int [] rijen: tabel) {voor (int rij: rijen) {loopCycles ++; if (rij == 37) {gevonden = waar; buiten breken; }}}

Als het nummer 37 is gevonden, wordt het gelabelde breken instructie beëindigt de buitenste voor lus, en er worden geen cycli meer uitgevoerd. Dus, loopCycles eindigt met de waarde van 5.

Het ongelabelde breken beëindigt alleen de binnenste uitspraak, waardoor de stroom van controle terugkeert naar de buitenste voor dat zet de lus voort naar de volgende rij in de tafel variabele, waardoor de loopCycles eindigen met een waarde van 8.

V9. Wat is het verschil tussen een ongelabeld en een gelabeld doorgaan met uitspraak?

Een ongelabeld doorgaan met instructie springt naar het einde van de huidige iteratie in het binnenste voor, terwijl, of doen terwijl loop, terwijl een gelabeld doorgaan met springt naar een buitenste lus gemarkeerd met het gegeven label.

Hier is een voorbeeld dat dit laat zien:

int [] [] table = {{1, 15, 3}, {25, 15, 49}, {15, 68, 93}}; int loopCycles = 0; buitenste: voor (int [] rijen: tabel) {voor (int rij: rijen) {loopCycles ++; if (row == 15) {ga door naar buiten; }}}

De redenering is dezelfde als in de vorige vraag. Het gelabelde doorgaan met instructie beëindigt de buitenste voor lus.

Dus, loopCycles eindigt met de waarde 5, terwijl de niet-gelabelde versie alleen de binnenste instructie beëindigt, waardoor de loopCycles eindigen met een waarde van 9.

V10. Beschrijf de uitvoeringsstroom in een probeer-vangst-eindelijk construeren.

Als een programma het proberen block, en een uitzondering wordt erin gegooid, de uitvoering van de proberen blok wordt onderbroken, en de stroom van controle gaat verder met een vangst blok dat de uitzondering kan verwerken die wordt gegenereerd.

Als een dergelijk blok niet bestaat, stopt de uitvoering van de huidige methode en wordt de uitzondering naar de vorige methode op de aanroepstack geworpen. Als alternatief, als er geen uitzondering optreedt, alle vangst blokken worden genegeerd en de uitvoering van het programma gaat normaal verder.

EEN Tenslotte block wordt altijd uitgevoerd, ongeacht of er een uitzondering is gegenereerd of niet in de hoofdtekst van het proberen blok.

V11. In welke situaties het Tenslotte blok mag niet worden uitgevoerd?

Wanneer de JVM wordt beëindigd tijdens het uitvoeren van het proberen of vangst blokkeert bijvoorbeeld door te bellen System.exit (), of wanneer de uitvoerende thread wordt onderbroken of gedood, wordt het laatste blok niet uitgevoerd.

V12. Wat is het resultaat van het uitvoeren van de volgende code?

openbare statische int toewijzing () {int nummer = 1; probeer {nummer = 3; if (true) {throw new Exception ("Test Exception"); } getal = 2; } catch (Exception ex) {return number; } tenslotte {nummer = 4; } retournummer; } System.out.println (opdracht ());

De code voert het nummer 3 uit. Hoewel de Tenslotte block wordt altijd uitgevoerd, dit gebeurt pas na de proberen blokkeer uitgangen.

In het voorbeeld is de terugkeer instructie wordt uitgevoerd voordat de proberen te vangen blok eindigt. Dus de opdracht aan aantal in de Tenslotte block heeft geen effect, aangezien de variabele al is teruggestuurd naar de aanroepende code van de assignment methode.

V13. In welke situaties probeer het eindelijk block kan worden gebruikt, zelfs als uitzonderingen mogelijk niet worden gegenereerd?

Dit blok is handig als we ervoor willen zorgen dat we niet per ongeluk het opschonen van bronnen die in de code worden gebruikt, omzeilen door een breken, doorgaan met of terugkeer uitspraak:

HeavyProcess heavyProcess = nieuwe HeavyProcess (); probeer {// ... return heavyProcess.heavyTask (); } eindelijk {heavyProcess.doCleanUp (); }

We kunnen ook situaties tegenkomen waarin we de uitzondering die wordt gegenereerd niet lokaal kunnen afhandelen, of we willen dat de huidige methode de uitzondering toch genereert terwijl we middelen vrijmaken:

public void doDangerousTask (taak taak) gooit ComplicatedException {probeer {// ... task.gatherResources (); if (task.isComplicated ()) {throw new ComplicatedException ("Te moeilijk"); } // ...} eindelijk {task.freeResources (); }}

V14. Hoe werkt probeer-met-middelen werk?

De probeer-met-middelen statement declareert en initialiseert een of meer bronnen voordat het proberen blok en sluit ze automatisch aan het einde van de instructie, ongeacht of het blok normaal of abrupt is voltooid. Elk object dat wordt geïmplementeerd AutoCloseable of Afsluitbaar interfaces kunnen als hulpmiddel worden gebruikt:

probeer (StringWriter writer = nieuwe StringWriter ()) {writer.write ("Hallo wereld!"); }

3. Conclusie

In dit artikel hebben we enkele van de meest gestelde vragen behandeld die in technische interviews voor Java-ontwikkelaars voorkomen, met betrekking tot controlestroomverklaringen. Dit moet alleen worden behandeld als het begin van verder onderzoek en niet als een uitputtende lijst.

Veel succes met je sollicitatiegesprek.

De volgende » Interviewvragen over Java-uitzonderingen (+ antwoorden) « Vorige Java Generics sollicitatievragen (+ antwoorden)