Ten student results using an object array

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static class Student {
        private final String name, rollNo;
        private final double[] marks;
        private double total, average;

The final marks field is an array reference; final prevents reassigning the field, not changing array elements. total and average hold calculated values.

        Student(String rollNo, String name, double[] marks) {
            if (marks.length == 0) throw new IllegalArgumentException("At least one subject required.");
            for (double mark : marks) if (!Double.isFinite(mark) || mark < 0 || mark > 100) throw new IllegalArgumentException("Invalid mark.");
            this.rollNo = rollNo; this.name = name; this.marks = marks.clone();
        }

Require at least one mark, check each finite value lies from 0 to 100, and assign marks.clone(). The clone gives the Student its own array so later changes to the caller’s array do not alter its recorded marks.

        double computeTotal() { total = 0; for (double mark : marks) total += mark; return total; }
        double computeAverage() { computeTotal(); average = total / marks.length; return average; }

computeTotal resets total before summing, so repeated calls do not double-count. computeAverage calls it and divides by the nonzero mark count using double arithmetic.

        String grade() { computeAverage(); return average >= 90 ? "A" : average >= 80 ? "B" : average >= 70 ? "C" : average >= 60 ? "D" : average >= 40 ? "E" : "F"; }
        void displayResult() { String letter = grade(); System.out.printf(Locale.ROOT,"%s | %s | total %.2f | average %.2f | grade %s%n",rollNo,name,total,average,letter); }
    }

The conditional chain tests 90, 80, 70, 60 and 40 in descending order. displayResult calls grade first so total and average are ready before formatting. A computed average below 40 gets F.

    // Exactly 10 students: roll/name/subject-count, then one mark per line for each.
    public static void main(String[] args) {
        try {
            Student[] students = new Student[10]; Set<String> rolls = new HashSet<>();
            for (int i = 0; i < students.length; i++) {

The driver reserves ten Student reference slots and a HashSet of roll strings. Its loop must fill every slot; it does not accept an arbitrary student count.

                String roll = text(), name = text(); int subjects = integer(1, 10); double[] marks = new double[subjects];
                for (int j = 0; j < subjects; j++) marks[j] = number(0,100);
                if (!rolls.add(roll)) throw new IllegalArgumentException("Duplicate roll number.");
                students[i] = new Student(roll,name,marks);

Read identity, 1–10 subjects and each checked mark. Set.add returns false if that roll was already present. Construct the Student only after those reads and the uniqueness check succeed.

            }
            for (Student student : students) student.displayResult();

After input for all ten students succeeds, call displayResult for each object. The enhanced for loop visits references already stored in the array.

        } catch (IllegalArgumentException e) { System.out.println("Invalid input: " + e.getMessage()); }
    }
}

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.