Beheer structuren in Java

1. Overzicht

In de meest elementaire zin is een programma een lijst met instructies. Controlestructuren zijn programmeerblokken die het pad dat we door die instructies volgen, kunnen veranderen.

In deze zelfstudie verkennen we besturingsstructuren in Java.

Er zijn drie soorten controlestructuren:

  • Voorwaardelijke takken, die we gebruiken voor het kiezen tussen twee of meer paden. Er zijn drie soorten in Java: als / anders / anders als, ternaire operator en schakelaar.
  • Loops die gewend zijn doorloop meerdere waarden / objecten en voer herhaaldelijk specifieke codeblokken uit. De basistypen voor lussen in Java zijn voor, terwijl en doen terwijl.
  • Branching statements, die gewend zijn verander de stroom van controle in lussen. Er zijn twee soorten in Java: breken en doorgaan met.

2. If / Else / Else If

De als / anders verklaring is de meest elementaire controlestructuur, maar kan ook worden beschouwd als de basis van besluitvorming bij het programmeren.

Terwijl als kan op zichzelf worden gebruikt, het meest voorkomende gebruiksscenario is kiezen tussen twee paden met als / anders:

if (count> 2) {System.out.println ("Count is hoger dan 2"); } else {System.out.println ("Aantal is lager of gelijk aan 2"); }

Theoretisch kunnen we oneindig ketenen of nesten als / anders blokkeert, maar dit zal de leesbaarheid van de code nadelig beïnvloeden, en daarom wordt het niet aangeraden.

In de rest van dit artikel zullen we alternatieve uitspraken onderzoeken.

3. Ternaire operator

We kunnen een ternaire operator gebruiken als een verkorte uitdrukking die werkt als een als / anders uitspraak.

Laten we onze zien als / anders weer voorbeeld:

if (count> 2) {System.out.println ("Count is hoger dan 2"); } else {System.out.println ("Aantal is lager of gelijk aan 2"); }

We kunnen dit als volgt refactoren met een ternair:

System.out.println (count> 2? "Count is hoger dan 2": "Count is lager of gelijk dan 2");

Hoewel ternary een geweldige manier kan zijn om onze code leesbaarder te maken, is het niet altijd een goede vervanging voor als / anders.

4. Schakelaar

Als we uit meerdere cases kunnen kiezen, kunnen we een schakelaar uitspraak.

Laten we opnieuw een eenvoudig voorbeeld bekijken:

int count = 3; switch (count) {case 0: System.out.println ("Count is gelijk aan 0"); breken; geval 1: System.out.println ("Aantal is gelijk aan 1"); breken; standaard: System.out.println ("Aantal is negatief of hoger dan 1"); breken; }

Drie of meer als / anders uitspraken kunnen moeilijk te lezen zijn. Als een van de mogelijke oplossingen die we kunnen gebruiken, kunnen we schakelaar, zoals hierboven te zien.

En houd daar ook rekening mee schakelaar heeft reikwijdte en invoerbeperkingen die we moeten onthouden voordat we het gebruiken.

5. Lussen

We gebruiken loops als we dezelfde code meerdere keren achter elkaar moeten herhalen.

Laten we eens kijken naar een snel voorbeeld van vergelijkbaar voor en terwijl type lussen:

voor (int i = 1; i <= 50; i ++) {methodToRepeat (); } int whileCounter = 1; while (whileCounter <= 50) {methodToRepeat (); whileCounter ++; } 

Beide codeblokken hierboven zullen bellen methodToRepeat 50 keer.

6. Pauze

We moeten gebruiken breken om vroeg uit een lus te stappen.

Laten we een snel voorbeeld bekijken:

Lijstnamen = getNameList (); String name = "John Doe"; int index = 0; for (; index <names.length; index ++) {if (names [index] .equals (name)) {break; }}

Hier zoeken we naar een naam in een lijst met namen en we willen stoppen met zoeken zodra we die hebben gevonden.

Een lus wordt normaal gesproken voltooid, maar we hebben gebruikt breken hier om dat te kortsluiten en vroegtijdig af te sluiten.

7. Ga verder

Simpel gezegd, doorgaan metbetekent om de rest van de lus over te slaan waarin we ons bevinden:

Lijstnamen = getNameList (); String name = "John Doe"; String list = ""; for (int i = 0; i <names.length; i ++) {if (names [i] .equals (name)) {ga verder; } lijst + = namen [i]; }

Hier slaan we het toevoegen van het duplicaat over namen in de lijst.

Zoals we hier hebben gezien, breken en doorgaan met kan handig zijn bij het herhalen, hoewel ze vaak kunnen worden herschreven terugkeer verklaringen of andere logica.

8. Conclusie

In dit korte artikel hebben we geleerd wat besturingsstructuren zijn en hoe we deze kunnen gebruiken om flow control in onze Java-programma's te beheren.

Alle code die in dit artikel wordt gepresenteerd, is beschikbaar op GitHub.