Felsökning i IntelliJ IDEA: en nybörjarguide

Hej alla i CodeGym-communityt! Låt oss idag prata om felsökning — vad är det och hur man felsöker i IntelliJ IDEA. Den här artikeln är avsedd för personer som redan har en minsta kunskap om Java Core. Det kommer inte att finnas några ramverk eller komplicerade procedurer för att publicera bibliotek. En lugn promenad. Så gör dig bekväm och låt oss komma igång!

Varför du behöver felsökningsläge

Låt oss omedelbart klargöra något för oss själva: det finns ingen kod utan buggar... Så här fungerar livet. Så vi ska inte falla i bitar och ge upp om vår kod inte fungerar som vi förväntat oss. Men vad ska vi göra? Tja, vi kunde lägga in System.out.printlnuttalanden överallt och sedan kamma igenom konsolens utdata i hopp om att hitta ett fel. Som sagt, du kan (och det gör folk) felsöka med noggrann loggning. Men om du kan köra din kod på en lokal maskin är det bättre att använda felsökningsläget . Jag vill genast notera att vi i den här artikeln kommer att överväga att felsöka ett projekt med IntelliJ IDEA.

Vad är felsökningsläge?

Felsökningsläge är till för att felsöka (kontrollera) löpande kod. Det gör det möjligt för dig att stoppa avrättningen på anvisade platser och se hur det går. Det låter dig förstå programmets tillstånd på en viss plats i koden. Det är precis som att kunna stanna klockan och titta på allt från sidan. Coolt, eller hur? Vårt mål är att snabbt och enkelt lära sig hur man felsöker applikationer med vår älskade IntelliJ IDEA-utvecklingsmiljö.

Vad du behöver för att börja felsöka

Här är några gratis råd: medan du läser den här artikeln, gör allt som kommer att beskrivas här - du har allt du behöver göra för att följa med. Vad du behöver:

1. IntelliJ IDEA version 2019.3.1 eller senare. Om någon inte har detta, här är en länk där du kan ladda ner det . Ladda ner Community Edition - det är den version jag kommer att använda.
2. Klona detta GitHub-projekt och importera det via IDEA.

Öppna IDÉ: Välj felsökningspresentationsprojektet och tryck på OK . Då kommer du att se följande fönster: Lämna de valda alternativen: Importera projekt från externa källor och Maven . Klicka på Slutför . Nu när vi har importerat projektet kan vi beskriva resten av processen med ett levande exempel.

Bara lite teori... jag lovar :D

För att börja felsöka ens lite, måste du förstå vad en brytpunkt är och vara bekant med några snabbtangenter. En brytpunkt är en speciell markör som indikerar var du vill att exekveringen av applikationen ska stoppa, möjligen baserat på applikationens tillstånd. Du kan ställa in en brytpunkt antingen genom att vänsterklicka på den vänstra sidopanelen eller genom att klicka på kodplatsen och trycka på Ctrl+F8 . Låt oss titta på tre typer av brytpunkter: linjebrytpunkter, fältvaktpunkter och och metodbrytpunkter. Så här ser det ut:

• På rad:

  Om en sats har ett lambda-uttryck, uppmanar IDEA dig att välja om du vill sätta brytpunkten på hela satsen eller specifikt på lambda-uttrycket:

• Om en metod:

• På en klass:

Brytpunkter kan tas bort genom att följa samma steg som användes för att lägga till dem. Det finns situationer när du vill inaktivera (stänga av) dem. För att göra detta, hitta ikonen i avsnittet Felsökning. Detta kommer att tysta alla brytpunkter. För att se vilka brytpunkter som har ställts in kan du antingen gå till Felsökningssektionen i det nedre vänstra hörnet och hitta ikonen, eller trycka på Ctrl+Skift+F8 : När du flyttar till listan med brytpunkter ser vi följande: Det finns två brytpunkter här:

• Bee.java:24 — i Bee-klassen på rad 24
• Main.java:14 — i Main-klassen på rad 14

Observera att dessa brytpunkter inte kommer att ställas in automatiskt om du har klonat projektet: du måste ställa in dem själv! Det finns också en Java Exception Breakpoints- sektion. Det är väldigt användbart. Här kan du lägga till en implicit brytpunkt så att programmet stannar innan du kastar något undantag eller ett specifikt undantag. Vi lägger till en implicit brytpunkt för RuntimeException. Detta är lätt att göra. Hitta "+"-ikonen i det övre vänstra hörnet. Klicka på den och välj Java Exception Breakpoints : I fönstret som visas, skriv namnet på undantaget som du vill lägga till, välj från listan och klicka OK : Det avslutar vår primer om hur man ställer in saker, så nu ska gå vidare med lite träning.

Låt oss gå och göra det här som kallas felsökning!

Jag kommer från en lång rad av biodlare i familjen, så projektet jag skapade för att illustrera felsökning beskriver modeller av processen för bin som samlar nektar, bearbetar nektar till honung och sedan får honung från bikupan. Enligt dokumentationen README-fil, som finns i projektets rotkatalog, är det förväntade beteendet för alla blommor från vilka nektar samlas in att mängden insamlad honung (som tar formen av en dubbel ) ska vara lika med hälften av den insamlade nektaren. Projektet har följande klasser:

• Bee — ett vanligt arbetsbi
• BeeQueen — drottningen
• BeeHive — bikupan
• HoneyPlant - en honungsväxt (nektarkälla) från vilken nektar samlas in
• Main — det är här vi hittar public static void main(), metoden där exekveringen börjar.

Om vi ​​kör main()metoden, då finner vi att inte bara vårt program inte beräknar mängden honung, det ger också ett undantag... Vi måste undersöka och fastställa vad problemet är. Från spårstapeln i det nedre högra hörnet kan vi se att ett RuntimeException kastades på HoneyPlant.java:20: Det var precis vad vi pratade om ovan. Låt oss se efter detta RuntimeException genom att köra main()metoden i felsökningsläge. För att göra detta, klicka på den gröna triangelpilen i IntelliJ IDEA bredvid metoden main(). Som ett resultat kommer vi att stoppa programmet för tillfället precis innan undantaget kastas och vi kommer att se denna ikon: För att få all tillgänglig information måste vi titta i felsökningssektionen. Den har en Variablespanel som visar alla tillgängliga variabler i den här delen av programmet:

• nektar = 1,0;
• nectarCapacity = -1,0.

Att kasta undantaget är vettigt, eftersom en honungsväxt inte kan ha en negativ mängd nektar. Men varför händer detta? När allt kommer omkring, på raderna 15-17 kontrollerar vi om nektarförrådet är slut och returnerar noll om det är:

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

Men problemet är att vi kontrollerar fel variabel. Detta är ett fel i koden. Istället för att kontrollera mängden nektar som finns tillgänglig i blomman (som lagras i variabeln nectarCapacity ) kontrollerar programmet värdet på metodens nektarparameter , vilket är mängden nektar som vi vill ta från blomman. Här är det! Vår första bugg! Efter att ha fixat detta får vi följande kod:

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

Kör nu main()metoden på vanligt sätt (Run 'Main.main()'). Det finns inget undantag, och programmet fungerar: Applikationen körs till slut och ger följande svar:

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

Allt skulle vara bra nu, men det här svaret är felaktigt... Enligt dokumentationen README -fil, omvandlas nektar till honung i förhållandet 2 till 1:

## Documentation
Presentation based on honey production.

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

Huvudmetoden har helt klart två honungsplantor med 30 respektive 40 enheter nektar. Så vi borde i slutändan få 35 enheter honung. Men programmet säger att vi får 33. Vart tog de andra två enheterna vägen? Låt oss ta reda på! För att göra detta, ställ in en brytpunkt i Main.main()metoden på rad 28, där beeHive.populateHoney()anropas och kör main()metoden i felsökningsläge: Vi kommer att överväga denna punkt mer i detalj. Programmet slutade köras innan rad 28 kördes. I den nedre delen ser vi avsnittet Debug, som visar all tillgänglig information om det program som körs. Som redan nämnts innehåller rutan Variabler alla variabler och objekt som är tillgängliga från den här delen av programmet. Ramrutan visar stegen som programmet går igenom - du kan titta på tidigare (frames) steg och se alla lokala data. För att fortsätta köra programmet kan du trycka på F9 eller den gröna ikonen, som visas nedan: För att stoppa programmet, klicka på den röda fyrkanten: För att starta om programmet i felsökningsläge, klicka på pilen: Vidare kan du fortsätta genom ansökan steg för steg med två nycklar:

• F8 — Gå igenom koden utan att gå in i metoder;
• F7 — Gå igenom koden och gå in i metoder.

I vårt fall måste vi trycka på F7 för att gå in i beeHive.populateHoney()metoden. När vi kliver in i det får vi: Nu ska vi använda F8 för att gå igenom den här metoden och beskriva vad som händer i den:

• Rad 25 — Stream API används för att samla nektar från alla bin
• Rad 26 — Den nyskapade honungen läggs till den befintliga honungen;
• Rad 27 — 2 enheter honung tilldelas för drottningen
• Rad 28 — Dessa två enheter tas bort från den totala mängden honung
• Rad 29 — Drottningen äter denna honung.

Så det var dit de två saknade enheterna gick! Hurra! Efter att ha pratat med en affärsanalytiker drar vi slutsatsen att dokumentationen README-filen innehåller ett fel och behöver uppdateras. Låt oss uppdatera README-filen:

## 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.

Var gjort. Vi har åtgärdat alla buggar vi hittade. Vi kan lugnt fortsätta med en självgod blick, smutta på kaffe och läsa artiklar om Stack Overflow CodeGym :)

Låt oss sammanfatta

I den här artikeln lärde vi oss:

• allas arbete har fel och felsökning är ett bra sätt att fixa dem
• vad en brytpunkt är och vilka typer av brytpunkter det finns
• hur man ställer in en brytpunkt för undantag
• hur man går igenom koden i felsökningsläge

Artikel att läsa

• Projektet som används i den här artikeln
• Hur felsökning kan göra dig till en bättre utvecklare
• Officiell dokumentation
• Typer av brytpunkter. Officiell dokumentation