عرض عملي: استخدام مساعد لفهم stack trace ثم التحقق منه

Examples

Example 1: run the program and read the trace (simple)

A program averages grades read as text (imagine they came from a form). One entry has the letter O instead of the digit 0.

public class Avg {
    static int parseGrade(String text) {
        return Integer.parseInt(text);
    }
    static double average(String[] raw) {
        int sum = 0;
        for (String r : raw) sum += parseGrade(r);
        return (double) sum / raw.length;
    }
    public static void main(String[] args) {
        System.out.println(average(new String[] {"80", "90", "7O"}));
    }
}

Running it prints:

Exception in thread "main" java.lang.NumberFormatException: For input string: "7O"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
	at java.base/java.lang.Integer.parseInt(Integer.java:662)
	at java.base/java.lang.Integer.parseInt(Integer.java:778)
	at Avg.parseGrade(Avg.java:3)
	at Avg.average(Avg.java:7)
	at Avg.main(Avg.java:11)

Read from the top: the exception is NumberFormatException with the offending text "7O". The first frame in our code is Avg.parseGrade(Avg.java:3), called from average line 7, called from main line 11.

Your hypothesis, written before asking: "Integer.parseInt rejects the text 7O because the last character is a letter, not a digit, so the crash is on the third element; the program does not handle bad input." (Line numbers in the Java frames can differ between Java versions.)

Example 2: ask, restate, and catch the planned mistake (practical)

The question you send:

Java 21, plain JDK.
Goal: average a list of grades that arrive as text.
Code: parseGrade and average (above, 9 lines).
Error: NumberFormatException: For input string: "7O"
       at Avg.parseGrade(Avg.java:3)  (full trace attached)
Tried: I think "7O" has a letter instead of zero. I have not
       checked with the debugger.
Question: why does it fail, and how should the program handle bad text?

Here is the scripted assistant reply:

parseInt fails because 7O is not a valid number. Java has a built-in safe parser, so replace line 3 with return Integer.tryParse(text);, which returns null for bad input instead of throwing.

Restate in your own words: the first sentence matches your hypothesis. The second makes a claim you have not seen before: a built-in Integer.tryParse. A method you never met is exactly what to verify (L02). Compile it:

public class Avg2 {
    public static void main(String[] args) {
        System.out.println(Integer.tryParse("7O"));
    }
}

Avg2.java:3: error: cannot find symbol
        System.out.println(Integer.tryParse("7O"));
                                  ^
  symbol:   method tryParse(String)
  location: class Integer
1 error

The Javadoc agrees: the parsing methods of Integer are parseInt, parseUnsignedInt, valueOf, and decode, and they report bad text by throwing NumberFormatException. tryParse is a hallucination; the confident tone was no evidence. Notice also what the reply missed: even with a safe parser, the program still needs a rule for what to do with the bad entry, and average divides by raw.length, which would include it.

You reply with the evidence: "The compiler says cannot find symbol: method tryParse(String) in class Integer, and the Javadoc has no such method. Please suggest a way to handle bad text using parseInt." The corrected answer suggests catching the exception, which you now understand because you read the documentation yourself.

Example 3: confirm the real cause, fix, and log (realistic)

First confirm the cause with the debugger rather than trusting either of us. (Menus differ between IntelliJ versions, so check your IDE's help.) Put a breakpoint in parseGrade at the parseInt line, with a condition such as text.equals("7O") if your IDE supports conditional breakpoints, run in debug mode, and inspect text. You should see the string 7O with a letter. Stepping into parseInt shows the exception being thrown for the non-digit character.

Now write the fix yourself. You decide: skip invalid entries, report them, and average only the valid ones; return 0 when there are none.

public class Avg3 {
    static int parseGrade(String text) {
        try {
            return Integer.parseInt(text.trim());
        } catch (NumberFormatException e) {
            System.out.println("skipping invalid grade: \"" + text + "\"");
            return -1;
        }
    }
    static double average(String[] raw) {
        int sum = 0;
        int count = 0;
        for (String r : raw) {
            int g = parseGrade(r);
            if (g >= 0) {
                sum += g;
                count++;
            }
        }
        return count == 0 ? 0 : (double) sum / count;
    }
    public static void main(String[] args) {
        System.out.println(average(new String[] {"80", "90", "7O"}));
        System.out.println(average(new String[] {"x"}));
    }
}

skipping invalid grade: "7O"
85.0
skipping invalid grade: "x"
0.0

The first run averages 80 and 90 only; the second proves an all-invalid input does not divide by zero. Using -1 as a marker is a simple choice; it works only because valid grades here are never negative. A different program might prefer a clearer design.

Your log entry:

Bug: grade average crash
Hypothesis: parseInt rejects "7O" (letter O), crash on element 3.
Assistant's answer: right cause; suggested Integer.tryParse (wrong).
Evidence: compiler "cannot find symbol: method tryParse(String)"; Javadoc
  lists no tryParse; debugger showed text = "7O".
Outcome: partly right. Cause correct, fix invented; also missed the
  divide-by-length issue. Fixed with try/catch and a count; tested.

What settled the disagreement? The compiler, the documentation, and the debugger, not the assistant's confidence.