3 Arten von Programmierfehlern und wie man sie vermeidet
Programmierfehler sind Fehler in der Funktionsweise von Anwendungen. Sie werden allgemein als "Bugs" bezeichnet, daher der Begriff "Debugging".
Als Entwickler werden Sie viel Zeit damit verbringen, Fehler zu beheben. Eine Reihe der Fehler, denen Sie begegnen werden, sind häufig, und wenn Sie sie kennen, können Sie sie von vornherein vermeiden.
Hier ist, was Sie über diese drei Arten von Programmierfehlern wissen müssen und wie Sie sich davor schützen können:
1. Laufzeit- oder Ausführungsfehler
Dies sind Fehler, die während der Ausführung eines Programms (dh zur Laufzeit) auftreten. Sie können dazu führen, dass ein Programm nicht richtig oder gar nicht ausgeführt wird.
Schwerwiegende Laufzeitfehler führen dazu, dass die Programmausführung angehalten wird, während die nicht schwerwiegenden dazu führen, dass die Ausführung beendet wird, jedoch mit falschen Ergebnissen.
Ein typischer Laufzeitfehler ist ein Division-durch-Null-Fehler. Die Division durch Null soll ein unendliches Ergebnis ergeben, aber leider haben wir noch keine Datenstruktur entwickelt, die diese Datenmenge speichern kann.
Daher führt eine Division durch Null zu einer arithmetischen Ausnahme im Java-Compiler.
2. Logikfehler
Logikfehler werden durch fehlerhafte Argumentation verursacht. Es ist wichtig zu beachten, dass diese Fehler nicht unbedingt auf einen von Ihnen gemachten „Fehler“ zurückzuführen sind. Sie können auftreten, weil Sie ein bestimmtes Ausführungsszenario nicht berücksichtigt haben.
Sie sind am schwierigsten zu handhaben. Dies liegt daran, dass Code mit einem logischen Fehler ein gültiges Programm in der Sprache ist, in der er geschrieben wurde. Daher wird kein Compilerfehler ausgelöst. Das einzige Problem ist, dass es falsche Ergebnisse liefert.
Ein schwerwiegender logischer Fehler führt dazu, dass die Programmausführung gestoppt wird, während ein nicht schwerwiegender Fehler die Fortsetzung der Programmausführung ermöglicht, jedoch mit falschen Ergebnissen.
Ein häufiger logischer Fehler ist ein Aus-um-Eins-Fehler. Dies tritt normalerweise auf, wenn eine Schleifenfortsetzungsbedingung angegeben wird. Angenommen, Sie möchten die ersten fünf Quadratzahlen ausdrucken.
Möglicherweise schreiben Sie den folgenden Code in Ihre for-Schleife, die nur die ersten vier solcher Zahlen liefert.
for( int x=1; x<5; x++){ System.out.ln(x*x); }Um einen solchen Fehler zu vermeiden, können Sie stattdessen das Zeichen <= verwenden. Die Verwendung des Kleiner-oder-Gleich-Zeichens ist intuitiver und es ist weniger wahrscheinlich, dass Sie Ihre relationalen Operationen durcheinander bringen.
Ein weiterer häufiger logischer Fehler besteht darin, dass beide geschweiften Klammern einer Kontrollanweisung weggelassen werden und der darunter liegende Körper einen Codeblock bildet, der unter seiner Kontrolle steht.
Sehen Sie sich das Beispiel unten an. Es prüft, ob eine Zufallszahl ungerade oder gerade ist, und gibt dann eine Ausgabe aus.
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
}
}Beachten Sie Zeile 11. Sie wird immer ausgeführt, unabhängig davon, ob die erhaltene Zufallszahl gerade ist. Dies wäre natürlich logisch falsch, wenn die erhaltene Zahl ungerade ist.
Das Einschließen beider System.out.println- Anweisungen in geschweifte Klammern { } hätte dies vermieden.
Ein weiterer logischer Fehler, auf den Sie achten müssen, besteht darin, dass keine Schleifenbeendigungsbedingung bereitgestellt wird. Dies führt zu einer Endlosschleife und Ihr Programm wird die Ausführung nie beenden.
3. Syntax- oder Kompilierzeitfehler
Dies sind Fehler, die durch Verletzungen der Sprachregeln von Java verursacht werden. Sie werden auch Kompilierungs- oder Kompilierzeitfehler genannt.
Dies sind die am einfachsten zu behandelnden Fehler, da Ihr Compiler sie immer meldet. Viele Compiler gehen sogar vor und teilen Ihnen die Zeile in Ihrem Code mit, in der der Fehler auftritt.
Fehlertoleranz
Ein praktischer Weg, mit Softwareproblemen umzugehen, besteht darin, Fehlertoleranz einzusetzen, indem eine Ausnahmebehandlung eingeschlossen wird. Dazu können Sie try..catch- Anweisungen verwenden.
Um mit der Programmausführung unabhängig von der im catch- Block abgefangenen Ausnahme fortzufahren, verwenden Sie die finally- Anweisung.
Die Syntax lautet:
try{ // Block to execute if there are no issues }
catch (Exception e){
// Block to handle issues found
}finally{ // Block to execute after catch
}Siehe das folgende Codebeispiel:
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");}
}
}Das obige Programm generiert eine Zufallszahl zwischen Null und 10 und verwendet diese Zahl dann, um einen Zählerwert zwischen 10 und 100 zu teilen. Wenn eine Division durch Null auftritt, fängt das System den Fehler ab und zeigt eine Meldung an.
Werden Sie besser beim Codieren
Es empfiehlt sich, Ihrem Code Kommentare hinzuzufügen. Dies wird Ihnen helfen, Ihre Dateien leicht zu durchsuchen, wenn Sie einen Fehler haben. Ein kleiner, aber sehr wichtiger Schritt zur Entwicklung starker Codierungspraktiken.
Mit guten Programmierpraktiken sollten Sie in der Lage sein, häufige Programmierfehler zu vermeiden.