Programmeringsfel är brister i hur applikationer fungerar. De kallas vanligtvis för “buggar”, därav termen “felsökning”.
Som utvecklare kommer du att ägna mycket tid åt att fixa buggar. Ett antal av de fel du kommer att möta är vanliga, och att känna till dem hjälper dig att förhindra dem i första hand.
Här är vad du behöver veta om dessa tre typer av programmeringsfel och hur du kan skydda dig mot dem:
1. Runtime eller Execution Errors
Dessa är fel som uppstår när ett program körs (dvs under körning). De kan göra att ett program inte körs korrekt eller till och med inte körs alls.
Fatala körtidsfel gör att programkörningen stoppas medan de icke-fatala gör att körningen avslutas, men med felaktiga resultat.
Ett typiskt körtidsfel är en division med nollfel. Division med noll är tänkt att ge ett oändligt resultat, men tyvärr har vi inte kommit fram till en datastruktur som kan lagra den mängden data ännu.
Därför leder division med noll till ett aritmetiskt undantag i Java-kompilatorn.
2. Logiska fel
Logiska fel orsakas på grund av felaktiga resonemang. Det är viktigt att notera att dessa fel inte nödvändigtvis beror på ett “misstag” du har gjort. De kan uppstå för att du inte övervägde ett visst exekveringsscenario.
De är svårast att hantera. Detta beror på att kod med ett logiskt fel är ett giltigt program på språket det är skrivet på. Därför kommer det inte att skapa ett kompilatorfel. Det enda problemet är att det ger felaktiga resultat.
Ett fatalt logiskt fel kommer att göra att programkörningen stoppas medan ett icke-fatalt kommer att tillåta programkörningen att fortsätta men med felaktiga resultat.
Ett vanligt logiskt fel är ett av-för-ett-fel. Detta inträffar normalt när man anger ett loop-fortsättningstillstånd. Säg att du vill skriva ut de första fem fyrkantstalen.
Det kan sluta med att du skriver koden nedan i din for-loop, som bara ger de fyra första sådana siffrorna.
for( int x=1; x<5; x++){ System.out.ln(x*x); }
För att undvika ett sådant fel kan du istället använda
Ett annat vanligt logiskt fel är att utelämna båda klammerparenteserna i en kontrollsats och ändå bildar kroppen nedan ett kodblock som är under dess kontroll.
Titta på exemplet nedan. Den kontrollerar om ett slumptal är udda eller jämnt och skriver sedan ut en utdata.
import java.util.Random;
public class OddEven{
public static void main(String[] args) {
Random numberGenerator = new Random();
int randomNumber = numberGenerator.nextInt(10);
if ((randomNumber%2)==0)
System.out.println("Here is your lucky number :" + randomNumber);
System.out.println("The number "+ randomNumber +" that you got is even"); // line 11
}
}
Observera rad 11. Det kommer alltid att köras oavsett om slumptalet du fick är jämnt. Detta skulle naturligtvis vara logiskt fel när siffran du fick är udda.
Inklusive båda System.out.println påståenden mellan klammerparenteser { }, skulle ha undvikit detta.
Ett annat logiskt fel att hålla utkik efter är att inte tillhandahålla ett loopavslutningsvillkor. Detta kommer att resultera i en oändlig loop och ditt program kommer aldrig att slutföras.
3. Syntax- eller kompileringsfel
Dessa är fel orsakade på grund av brott mot Javas språkregler. De kallas också kompilerings- eller kompileringsfel.
Dessa är de enklaste felen att hantera eftersom din kompilator alltid kommer att rapportera dem. Många kompilatorer går till och med vidare och berättar att raden i din kod felet är på.
Feltolerans
Ett praktiskt sätt att hantera programvaruproblem är att använda feltolerans genom att inkludera undantagshantering. Du kan använda försök fånga uttalanden för att uppnå detta.
Att fortsätta med programexekveringen oavsett undantaget i fånga blockera, använd till sist påstående.
Syntaxen är:
try{ // Block to execute if there are no issues }
catch (Exception e){
// Block to handle issues found
}finally{ // Block to execute after catch
}
Se kodexemplet nedan:
import java.util.Random;
public class RandomNumbers{
public static void main(String[] args) {
Random numberGenerator = new Random();
try{
for (int counter = 10; counter<=100; counter++){
int randomNumber = numberGenerator.nextInt(10);
System.out.println(counter/randomNumber); } }
catch(Exception e){
System.out.println("Division by zero encountered!");
}
finally{
System.out.println("Infinite value got");}
}
}
Ovanstående program genererar ett slumpmässigt tal mellan noll och 10 och använder sedan det numret för att dividera ett räknarvärde mellan 10 och 100. Om division med noll påträffas, fångar systemet felet och visar ett meddelande.
Bli bättre på kodning
Det är bra att lägga till kommentarer till din kod. Detta hjälper dig att enkelt kamma igenom dina filer när du har en bugg. Ett litet, men mycket viktigt steg för att utveckla starka kodningsmetoder.
Med bra kodningsmetoder bör du kunna undvika vanliga programmeringsmisstag.
Om författaren
Jerome Davidson (33 artiklar publicerade)
Jerome är personalskribent på MakeUseOf. Han täcker artiklar om programmering och Linux. Han är också en kryptoentusiast och håller alltid koll på kryptoindustrin.
Mer från Jerome Davidson
Prenumerera på vårt nyhetsbrev
Gå med i vårt nyhetsbrev för tekniska tips, recensioner, free e-böcker och exklusiva erbjudanden!
Klicka här för att prenumerera
