Foutopsporing in IntelliJ IDEA: een beginnershandleiding

Hallo iedereen in de CodeGym-community! Laten we het vandaag hebben over foutopsporing - wat is het en hoe foutopsporing in IntelliJ IDEA. Dit artikel is bedoeld voor mensen die al een minimale kennis van Java Core hebben. Er zullen geen kaders of ingewikkelde procedures zijn om bibliotheken te publiceren. Een rustige wandeling. Dus maak het jezelf gemakkelijk en laten we aan de slag gaan!

Waarom u de foutopsporingsmodus nodig heeft

Laten we meteen iets voor onszelf verduidelijken: er is geen code zonder bugs... Dit is gewoon hoe het leven werkt. We moeten dus niet uit elkaar vallen en opgeven als onze code niet werkt zoals we hadden verwacht. Maar wat moeten we doen? Nou, we zouden overal verklaringen kunnen plaatsen System.out.printlnen dan de console-uitvoer doorzoeken in de hoop een fout te vinden. Dat gezegd hebbende, je kunt (en mensen doen) debuggen door zorgvuldig te loggen. Maar als u uw code op een lokale computer kunt uitvoeren, is het beter om de foutopsporingsmodus te gebruiken . Ik wil meteen opmerken dat we in dit artikel zullen overwegen om een ​​project te debuggen met behulp van IntelliJ IDEA.

Wat is de foutopsporingsmodus?

Debug-modus is voor het debuggen (controleren) van lopende code. Het maakt het voor u mogelijk om de uitvoering op aangewezen plaatsen te stoppen en te kijken hoe de zaken vorderen. Hiermee kunt u de status van het programma op een bepaalde plaats in de code begrijpen. Het is net alsof je de klok kunt stilzetten en alles vanaf de zijkant kunt bekijken. Cool toch? Ons doel is om snel en gemakkelijk te leren hoe u applicaties kunt debuggen met behulp van onze geliefde IntelliJ IDEA-ontwikkelomgeving.

Wat je nodig hebt om te beginnen met debuggen

Hier is wat gratis advies: doe tijdens het lezen van dit artikel alles wat hier wordt beschreven - je hebt alles wat je nodig hebt om mee te doen. Wat je nodig hebt:

1. IntelliJ IDEA versie 2019.3.1 of hoger. Mocht iemand dit niet hebben, hier is een link waar je het kunt downloaden . Download de Community-editie - dat is de versie die ik zal gebruiken.
2. Kloon dit GitHub-project en importeer het via IDEA.

IDEA openen: Selecteer het debug- presentatieproject en druk op OK . Vervolgens ziet u het volgende venster: Laat de geselecteerde opties staan: Importeer project uit externe bronnen en Maven . Klik op Voltooien . Nu we het project hebben geïmporteerd, kunnen we de rest van het proces beschrijven met een levend voorbeeld.

Gewoon een beetje theorie... Ik beloof het :D

Om zelfs maar een klein beetje te debuggen, moet je begrijpen wat een breekpunt is en bekend zijn met een paar sneltoetsen. Een breekpunt is een speciale markering die aangeeft waar de uitvoering van de toepassing moet stoppen, mogelijk op basis van de status van de toepassing. U kunt een breekpunt instellen door met de linkermuisknop te klikken in het linkerzijpaneel of door op de codelocatie te klikken en op Ctrl+F8 te drukken . Laten we eens kijken naar drie soorten breekpunten: lijnbreekpunten, veldcontrolepunten en methode-breekpunten. Zo ziet het eruit:

• Op een lijn:

  Als een instructie een lambda-expressie heeft, vraagt ​​IDEA u om te kiezen of u het breekpunt op de volledige instructie of specifiek op de lambda-expressie wilt plaatsen:

• Op een methode:

• Op een klas:

Breekpunten kunnen worden verwijderd door dezelfde stappen te volgen die zijn gebruikt om ze toe te voegen. Er zijn situaties waarin u ze wilt deactiveren (dempen). Zoek hiervoor het pictogram in het gedeelte Foutopsporing. Hiermee worden alle breekpunten gedempt. Om te zien welke breekpunten zijn ingesteld, kunt u ofwel naar de sectie Debug in de linkerbenedenhoek gaan en het pictogram zoeken, of op Ctrl+Shift+F8 drukken : Als we naar de lijst met breekpunten gaan, zien we het volgende: Er zijn twee breekpunten hier:

• Bee.java:24 - in de Bee-klasse op regel 24
• Main.java:14 — in de Main-klasse op regel 14

Houd er rekening mee dat deze breekpunten niet automatisch worden ingesteld als u het project heeft gekloond: u moet ze zelf instellen! Er is ook een gedeelte Java Exception Breakpoints . Het is heel handig. Hier kunt u een impliciet breekpunt toevoegen, zodat het programma stopt voordat er een uitzondering of een specifieke uitzondering wordt gegenereerd. We voegen een impliciet breekpunt toe voor RuntimeException. Dit is gemakkelijk te doen. Zoek het pictogram "+" in de linkerbovenhoek. Klik erop en selecteer Java Exception Breakpoints : In het venster dat verschijnt, schrijft u de naam van de uitzondering die u wilt toevoegen, selecteert u deze in de lijst en klikt u op OK : Hiermee is onze inleiding over het instellen afgesloten, dus nu gaan we Ik ga wat oefenen.

Laten we gaan doen wat we debuggen noemen!

Ik kom uit een lange rij familie-imkers, dus het project dat ik heb gemaakt om foutopsporing te illustreren, beschrijft het proces van bijen die nectar verzamelen, nectar verwerken tot honing en vervolgens honing uit de bijenkorf halen. Volgens het README- documentatiebestand , dat te vinden is in de hoofdmap van het project, is het verwachte gedrag van alle bloemen waarvan nectar wordt verzameld, dat de hoeveelheid verzamelde honing (die de vorm aanneemt van een dubbele ) gelijk is aan de helft van de verzamelde nectar. Het project heeft de volgende klassen:

• Bij - een gewone werkbij
• BeeQueen - de bijenkoningin
• Bijenkorf - de bijenkorf
• HoneyPlant - een honingplant (nectarbron) waaruit nectar wordt verzameld
• Main - hier vinden we public static void main()de methode waar de uitvoering begint.

Als we de main()methode uitvoeren, ontdekken we dat ons programma niet alleen de hoeveelheid honing niet berekent, maar ook een uitzondering genereert... We moeten onderzoeken en bepalen wat het probleem is. Aan de trace-stack in de rechter benedenhoek kunnen we zien dat er in een RuntimeException naar werd gegooid HoneyPlant.java:20: dat is precies waar we het hierboven over hadden. Laten we naar deze RuntimeException kijken door de main()methode in foutopsporingsmodus uit te voeren. Klik hiervoor op de groene driehoekpijl in IntelliJ IDEA naast de main()methode. Als gevolg hiervan laten we het programma stoppen op het moment net voordat de uitzondering wordt gegenereerd en zien we dit pictogram: Om alle beschikbare informatie te krijgen, moeten we kijken in de Debug-sectie. Het heeft een variabelenpaneel dat alle variabelen toont die beschikbaar zijn in dit deel van de applicatie:

• nektar = 1,0;
• nectarCapaciteit = -1.0.

Het gooien van de uitzondering is logisch, omdat een honingplant geen negatieve hoeveelheid nectar kan hebben. Maar waarom gebeurt dit? In regels 15-17 controleren we immers of de nectarvoorraad op is en geven we nul terug als:

	if (nectar == 0) {
   	     return 0;
}

Maar het probleem is dat we de verkeerde variabele controleren. Dit is een fout in de code. In plaats van de beschikbare hoeveelheid nectar in de bloem te controleren (die is opgeslagen in de variabele nectarCapacity ), controleert het programma de waarde van de nectarparameter van de methode , de hoeveelheid nectar die we van de bloem willen nemen. Hier is het! Onze eerste bug! Nadat we dit hebben opgelost, krijgen we de volgende code:

	if (nectarCapacity == 0) {
   	     return 0;
}

Voer de methode nu main()op de normale manier uit (Run 'Main.main()'). Er wordt geen uitzondering gegenereerd en het programma werkt: de toepassing wordt voltooid en geeft het volgende antwoord:

"33.0 honey was produced by 7 bees from 2 honey plants"

Alles zou nu in orde zijn, maar dit antwoord is onjuist... Volgens het documentatie -README-bestand wordt nectar omgezet in honing in een verhouding van 2 op 1:

## Documentation
Presentation based on honey production.

**Note**: 2 units of nectar = 1 unit of honey

De hoofdmethode heeft duidelijk twee honingplanten met respectievelijk 30 en 40 eenheden nectar. Dus we zouden uiteindelijk moeten eindigen met 35 eenheden honing. Maar het programma vertelt ons dat we er 33 krijgen. Waar zijn de andere twee eenheden gebleven? Dat zoeken we uit! Om dit te doen, stelt u een breekpunt in de Main.main()methode in op regel 28, waar beeHive.populateHoney()wordt aangeroepen en voert u de main()methode uit in de foutopsporingsmodus: We zullen dit punt in meer detail bekijken. Het programma stopte met uitvoeren voordat regel 28 werd uitgevoerd. In het onderste gedeelte zien we de Debug-sectie, die alle beschikbare informatie over de draaiende applicatie laat zien. Zoals eerder vermeld, bevat het deelvenster Variabelen alle variabelen en objecten die beschikbaar zijn in dit deel van de toepassing. Het deelvenster Frames toont de stappen die de toepassing doorloopt — u kunt eerdere (frames) stappen bekijken en alle lokale gegevens bekijken. Om door te gaan met het uitvoeren van het programma, kunt u op F9 of op het groene pictogram drukken, zoals hieronder weergegeven: Om het programma te stoppen, klikt u op het rode vierkant: Om de toepassing opnieuw te starten in foutopsporingsmodus, klikt u op de pijl: Verder kunt u doorgaan met de toepassing stap voor stap met behulp van twee toetsen:

• F8 - Stap door de code zonder in methoden te stappen;
• F7 - Stap door code en stap in methoden.

In ons geval moeten we op F7 drukken om in de beeHive.populateHoney()methode te stappen. Als we erin stappen, krijgen we: Nu gebruiken we F8 om door deze methode te stappen en te beschrijven wat erin gebeurt:

• Regel 25 — De Stream API wordt gebruikt om nectar van alle bijen te verzamelen
• Regel 26 — De nieuw gecreëerde honing wordt toegevoegd aan de bestaande honing;
• Regel 27 - 2 eenheden honing worden toegewezen aan de koningin
• Regel 28 — Deze twee eenheden worden verwijderd van de totale hoeveelheid honing
• Regel 29 — De koningin eet deze honing.

Dus daar gingen de twee ontbrekende eenheden! Hoera! Na een gesprek met een bedrijfsanalist concluderen we dat het documentatie -README-bestand een fout bevat en moet worden bijgewerkt. Laten we het README-bestand bijwerken:

## Documentation
Presentation based on honey production.

**Note**:
* 2 units of nectar = 1 unit of honey
* The queen bee eats 2 units of honey every time when beehive is replenished with honey.

Werden gedaan. We hebben alle bugs opgelost die we hebben gevonden. We kunnen rustig doorgaan met een zelfvoldane blik, koffie drinken en artikelen lezen op Stack Overflow CodeGym :)

Laten we samenvatten

In dit artikel leerden we:

• ieders werk bevat fouten en foutopsporing is een geweldige manier om ze op te lossen
• wat een breekpunt is en welke soorten breekpunten er zijn
• hoe u een uitzonderingsbreekpunt instelt
• stap voor stap door code in foutopsporingsmodus

Artikel om te lezen

• Het project dat in dit artikel wordt gebruikt
• Hoe foutopsporing u een betere ontwikkelaar kan maken
• Officiële documentatie
• Soorten breekpunten. Officiële documentatie