SkillForge | ATLAS

Fehler im Quellcode finden

8 min read

Fehler im Quellcode finden

In dieser interaktiven Lerneinheit lernst du die wichtigsten Fehlerarten beim Programmieren kennen und übst deren systematische Erkennung. Du trainierst anhand praktischer Beispiele, wie du Syntax-, Laufzeit- und logische Fehler unterscheidest und behebst. Durch gezielte Übungen entwickelst du die Fähigkeit, typische Programmierfehler wie falsche Vergleichsoperatoren oder Array-Zugriffe selbstständig zu identifizieren und zu korrigieren.

Einführung

Kennst du die Situation, dass dein Code nicht funktioniert und du lange nach der Ursache suchst, bis du schließlich feststellst, dass lediglich ein Semikolon fehlt? Solche kleinen Fehler verursachen oft großen Frust.

In dieser Lerneinheit erfährst du:

  • Welche verschiedenen Fehlerarten es in der Programmierung gibt.
  • Wie diese Fehler entstehen.
  • Wie man sie findet und vermeidet

Lernziele

Nach dieser Lerneinheit kannst du:

  • lexikalische, syntaktische, semantische, logische und Laufzeitfehler unterscheiden.

  • erklären, warum diese Fehlerarten auftreten und wie du sie in deinem Code erkennst.

  • typische Fehler in kleinen Codebeispielen identifizieren, beheben und dein Wissen auf ein praxisnahes Szenario anwenden.

Überleitung

Wir starten mit den Fehlerarten, die du meist schon beim Tippen oder während des Kompilierens bemerkst: lexikalische und syntaktische Fehler. Danach schauen wir auf die semantischen Fehler, gefolgt von logischen und Laufzeitfehlern.

Lexikalische Fehler

Was sind Lexikalische Fehler?

Diese Fehler entstehen, wenn du Wörter und Symbole falsch schreibst oder vertauschst. Du kannst dir das wie Rechtschreibfehler in der normalen Sprache vorstellen – nur dass es in Java um Schlüsselwörter, Bezeichner und Sonderzeichen geht.

Beispiel (Java):

publc class MyProgram {
    public sttic Strng main(String[] args) {
        System.out.println("Hallo Welt");
    }

Erläuterung:

publc ist falsch geschrieben (korrekt: public), sttic statt static, Strng statt String.

All diese Tippfehler führen dazu, dass der Java-Compiler die Wörter nicht erkennt.

Syntaktische Fehler

Was sind Syntaktische Fehler?

Hier ist die Schreibweise jedes Wortes korrekt, aber du verstößt gegen die Grammatikregeln der Sprache. Zum Beispiel fehlen Klammern, Semikolons oder die Reihenfolge von Schlüsselwörtern passt nicht.

Beispiel (Java):

public class SyntacticDemo
{
    public static void main(String[] args)
        System.out.println("Hallo");
    }

Erläuterung

  • Nach main(String[] args) fehlt eine öffnende geschweifte Klammer {.
  • Dadurch ist die Blockstruktur nicht korrekt, was zu einem syntaktischen Fehler führt.

Semantische Fehler

Was sind Semantische Fehler?

Die Wörter sind richtig geschrieben und die Syntax stimmt, aber du verletzt die „Bedeutungsregeln“ der Sprache. Ein typisches Beispiel ist, dass du Variablen verwendest, ohne sie zu deklarieren, oder Datentypen unpassend einsetzt.

Beispiel (Java):

public class SemanticDemo {
    public static void main(String[] args) {
        double summe = 5.0;
        summe = summe + wert;
    }
}

Erläuterung:

  • wert wurde nicht deklariert.
    • Obwohl Schreibweise und Syntax korrekt aussehen, erkennt der Compiler diesen semantischen Fehler mit der Meldung: „cannot find symbol ‚wert‘“.
⏳ Lädt Dataview-Inhalt...

Logische Fehler

Was sind Logische Fehler?

Hier ist der Code zwar grammatisch und semantisch korrekt, aber die Berechnung oder Logik stimmt nicht. Der Compiler bemerkt diesen Fehler nicht – das Programm läuft, gibt aber falsche Ergebnisse.

Beispiel (Java)

Angenommen, wir möchten den Durchschnitt von drei Zahlen berechnen. Der Code sieht auf den ersten Blick korrekt aus, aber ein Fehler kann auftreten, wenn die Division durch eine falsche Zahl erfolgt.

public class LogicDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        double avg = (a + b + c) / 2;

        System.out.println("Durchschnitt: " + avg);
    }
}

Erläuterung:

  • Wenn man versehentlich durch eine falsche Zahl teilt, wird zwar ein Wert berechnet, aber er ist falsch. Da der Compiler solche Fehler nicht erkennt, bleibt der Fehler unbemerkt, bis das falsche Ergebnis auffällt.

  • Um den Durchschnitt korrekt zu berechnen, muss die Summe durch 3 geteilt werden.

Laufzeitfehler

Was sind Laufzeitfehler?

Diese Fehler treten erst auf, wenn das Programm ausgeführt wird – beispielsweise, wenn du auf ein nicht vorhandenes Array-Element zugreifst oder versuchst, durch null zu dividieren.

Beispiel (Java)

public class RuntimeDemo {
    public static void main(String[] args) {
        String text = null;

        System.out.println(text.length());
    }
}

Erläuterung:

  • text zeigt auf null, daher ist text.length() zur Laufzeit ungültig und wirft eine NullPointerException.
⏳ Lädt Dataview-Inhalt...

Praxisnahes Szenario

Stell dir vor, du hast ein Trouble-Ticket-System, bei dem aus integerbasierten Messwerten ein Durchschnitt berechnet wird. Die Werte könnten z. B. **[4, 2, 8, 1] **sein. Du stellst fest, dass das Programm aber nur die „2“ als Ergebnis liefert, statt den korrekten Durchschnitt von 3.75.

Aufgabe

Im Code unten findest du Fehler, die zu einem falschen Durchschnitt führen:

int durchschnitt = 0;
int summe = 0;

for(int i = 1; i < daten.length; i++) {
    summe = summe + daten[i];
}

durchschnitt = summe / daten.length;
  1. Finde und korrigiere die Fehler, damit der exakte Durchschnitt als Kommazahl berechnet wird.
  2. Erkläre, welche Fehlerkategorien vorliegen.
Mögliche Lösung 
double durchschnitt = 0.0;  // Statt int
int summe = 0;
 
for(int i = 0; i < daten.length; i++) { // Schleife ab Index 0
    summe += daten[i];
}
 
durchschnitt = (double) summe / daten.length; // Kommazahl
  • Da daten[0] im ursprünglichen Code übergangen wurde, fehlte ein Element.
  • durchschnitt sollte ein Gleitkommawert sein (double), da wir Nachkommastellen brauchen.
  • Durch (double) summe stellen wir sicher, dass eine Fließkommadivision stattfindet.
  • Es handelt sich um einen logischen Fehler, weil der Code zwar syntaktisch und semantisch korrekt ist, jedoch die Berechnungslogik falsch implementiert wurde. Das Programm läuft fehlerfrei, liefert aber aufgrund des übersehenen Elements im Array und der falschen Division einen inkorrekten Durchschnittswert.

Zusammenfassung

In der Programmierung unterscheidet man hauptsächlich folgende Fehlerarten:

1. Lexikalische Fehler

  • Tipp- und Schreibfehler in Schlüsselwörtern, Bezeichnern oder Symbolen.
  • Beispiel: int nuummer = 5; statt int nummer = 5;

2. Syntaktische Fehler

  • Verletzung der Grammatikregeln der verwendeten Programmiersprache.
  • Beispiel: Fehlende Klammern oder Semikolons (;), falsche Reihenfolge von Anweisungen.
if (x > 5)
    System.out.println("x ist größer als 5")

(fehlendes Semikolon)

3. Semantische Fehler

  • Formal korrekter Code, der jedoch inhaltlich nicht sinnvoll ist.
  • Beispiel: Verwendung nicht deklarierter Variablen oder falscher Datentypen.
String zahl = 10; // falscher Datentyp

4. Logische Fehler

  • Programm läuft durch, aber liefert falsche oder unerwartete Ergebnisse.
  • Beispiel: Falsche Berechnung durch falschen Operator oder falsche Bedingung.
int summe = a - b; // sollte a + b sein

5. Laufzeitfehler

  • Fehler, die erst während der Ausführung des Programms auftreten.
  • Beispiel: NullPointerException, ArrayIndexOutOfBoundsException.
String text = null;
int länge = text.length(); // wirft NullPointerException

Mit diesem Wissen bist du nun besser darauf vorbereitet, Fehler in deinen Programmen schnell zu erkennen und systematisch zu beheben.

Graphansicht

Backlinks