Case study: a step-by-step gradebook (GradeBook)

There is no new topic in the last week. We combine everything you learned during the semester in a single realistic program: the gradebook of a course. The program is small, but it contains a class, a constructor, a private field, an array field, a static helper method, an ArrayList, toString, printf, nested loops and a null check. The long writing question on the final exam looks exactly like this: “Write this class, then write this class that uses it.”

Strategy: do not try to write the program in one go. Write a small piece, try it in main, see that it works, then grow it (incremental development).

Step 0: Break the problem down

The request: “Keep a course’s students and their grades. Compute each student’s average and letter grade. Find the class average, the most successful student and the number of passing students. Print a report and a letter grade histogram.”

Nouns are candidates for classes and fields, verbs are candidates for methods:

+-------------------------------------+       +----------------------------------------+
|              Student                |       |               GradeBook                |
+-------------------------------------+       +----------------------------------------+
| - created : int  (static)           |       | - courseName : String                  |
| - name : String  (final)            |  0..* | - students : ArrayList<Student>        |
| - scores : int[] (final)            |<------|                                        |
+-------------------------------------+       +----------------------------------------+
| + Student(name : String,            |       | + GradeBook(courseName : String)       |
|           scores : int[])           |       | + addStudent(s : Student) : void       |
| + getName() : String                |       | + classAverage() : double              |
| + setScore(i : int, v : int) : void |       | + topStudent() : Student               |
| + average() : double                |       | + countPassing(limit : double) : int   |
| + highest() : int                   |       | + find(name : String) : Student        |
| + letterFor(avg : double) : String  |       | + printReport() : void                 |
|   (static)                          |       | + printHistogram() : void              |
| + letter() : String                 |       +----------------------------------------+
| + toString() : String               |
+-------------------------------------+

GradeBook has a list of students (composition). The arrow shows that GradeBook uses Students.

Step 1: The Student class

class Student {
    private static int created = 0;          // how many students were created
    private final String name;
    private final int[] scores;

    public Student(String name, int[] scores) {
        this.name = name;
        this.scores = new int[scores.length];            // its own array
        for (int i = 0; i < scores.length; i++) this.scores[i] = scores[i];
        created++;
    }

    public String getName() { return name; }
    public static int getCreated() { return created; }

    public void setScore(int index, int value) {
        if (index >= 0 && index < scores.length && value >= 0 && value <= 100) {
            scores[index] = value;
        }
    }

    public double average() {
        int sum = 0;
        for (int sc : scores) sum += sc;
        return (double) sum / scores.length;             // no int division trap
    }

    public int highest() {
        int max = scores[0];
        for (int sc : scores) if (sc > max) max = sc;
        return max;
    }

    public static String letterFor(double avg) {        // no object needed
        if (avg >= 90) return "A";
        else if (avg >= 80) return "B";
        else if (avg >= 70) return "C";
        else if (avg >= 60) return "D";
        else return "F";
    }

    public String letter() { return letterFor(average()); }

    @Override
    public String toString() {
        return String.format("%-6s %6.2f %s", name, average(), letter());
    }
}

Design decisions:

• The fields are private final. The references to the name and the grade array are assigned once. (The elements of a final array can still change; setScore does this in a controlled way.)
• The constructor copies the array. If we had written this.scores = scores;, we would share the same array with the outside, and every change made outside would change the student’s grades (the constructor version of the getter trap in week 13). This is called a defensive copy.
• setScore checks two things: that the index is valid (otherwise ArrayIndexOutOfBoundsException) and that the grade is between 0 and 100.
• letterFor is static. You do not need a student object to compute a letter; a number is enough. letter(), on the other hand, is an instance method and passes its own average to letterFor.
• toString uses a printf format. %-6s left-aligns the name in a field of 6 characters, %6.2f writes the average right-aligned with 2 decimals. This way the report comes out aligned.

Test it:

Student s = new Student("Deniz", new int[]{70, 85, 90});
System.out.println(s.getName() + " " + s.average() + " " + s.highest() + " " + s.letter());
System.out.println(s);

Deniz 81.66666666666667 90 B
Deniz   81.67 B

new int[]{70, 85, 90} is the way to create an array and pass it directly as an argument without declaring an array variable.

Step 2: The GradeBook class

class GradeBook {
    private String courseName;
    private ArrayList<Student> students = new ArrayList<>();

    public GradeBook(String courseName) { this.courseName = courseName; }

    public void addStudent(Student s) { students.add(s); }
    public int size() { return students.size(); }

    public double classAverage() {
        if (students.isEmpty()) return 0.0;
        double total = 0;
        for (Student s : students) total += s.average();
        return total / students.size();
    }

    public Student topStudent() {
        if (students.isEmpty()) return null;
        Student top = students.get(0);
        for (Student s : students) {
            if (s.average() > top.average()) top = s;
        }
        return top;
    }

    public int countPassing(double limit) {
        int count = 0;
        for (Student s : students) if (s.average() >= limit) count++;
        return count;
    }

    public Student find(String name) {
        for (Student s : students) {
            if (s.getName().equals(name)) return s;
        }
        return null;
    }
}

Notice: GradeBook never touches the grade array anywhere. It asks the student itself for the average (s.average()). Each class is responsible for its own data; this is what we called encapsulation.

Test it:

GradeBook book = new GradeBook("SEN1001");
book.addStudent(new Student("Deniz", new int[]{70, 85, 90}));
book.addStudent(new Student("Ece", new int[]{95, 88, 92}));
book.addStudent(new Student("Can", new int[]{40, 55, 49}));
book.addStudent(new Student("Mert", new int[]{60, 72, 66}));
System.out.println(book.size());
System.out.printf("%.2f%n", book.classAverage());
System.out.println(book.topStudent().getName());
System.out.println(book.countPassing(60));
System.out.println(book.find("Ece").letter() + " " + book.find("Zeynep"));

4
71.83
Ece
3
A null

For Zeynep, who could not be found, find returned null; in String concatenation it appeared as the text null. If you had written book.find("Zeynep").letter() you would get a NullPointerException.

Step 3: Report and histogram

public void printReport() {
    System.out.println("Course: " + courseName);
    for (Student s : students) System.out.println(s);          // toString automatically
    System.out.printf("Class average: %.2f%n", classAverage());
    System.out.println("Top: " + topStudent().getName());
}

public void printHistogram() {
    String[] labels = {"A", "B", "C", "D", "F"};
    for (String lab : labels) {                                // outer: letters
        System.out.print(lab + ": ");
        for (Student s : students) {                           // inner: students
            if (s.letter().equals(lab)) System.out.print("*");
        }
        System.out.println();
    }
}

Course: SEN1001
Deniz   81.67 B
Ece     91.67 A
Can     48.00 F
Mert    66.00 D
Class average: 71.83
Top: Ece
A: *
B: *
C: 
D: *
F: *

PITFALL · using a method that may return null blindly. On an empty gradebook, printReport printed Course: BOS and Class average: 0.00 and then crashed with a NullPointerException on the line topStudent().getName(). Take a result that may be null into a variable first and check it: Student top = topStudent(); if (top != null) System.out.println("Top: " + top.getName());.

Where is each topic of the semester in this program?

On a final question, any row of this table can be asked on its own. If you can put them all together, you have reached the goal of the course.

Common mistakes

Student s = new Student("A", new int[]{50, 60, 80});
System.out.println(s.average() + " " + s.letter());

Student s = new Student("B", new int[]{89, 90, 91});
System.out.println(s.letter() + " " + s.highest());

int[] marks = {10, 20, 30};
Student s = new Student("C", marks);
marks[0] = 100;
System.out.println(s.highest());

GradeBook g = new GradeBook("X");
g.addStudent(new Student("P", new int[]{100}));
g.addStudent(new Student("Q", new int[]{0, 100}));
System.out.println(g.classAverage() + " " + g.countPassing(50));

System.out.println(Student.letterFor(59.99) + Student.letterFor(60)
        + Student.letterFor(89.5) + Student.letterFor(90));

Student s = new Student("D", new int[]{80, 80});
s.setScore(1, 100);
s.setScore(5, 100);
s.setScore(0, -10);
System.out.println(s.average());

GradeBook h = new GradeBook("Y");
h.addStudent(new Student("Ali", new int[]{70}));
h.addStudent(new Student("Ali", new int[]{90}));
System.out.println(h.find("Ali").average());

GradeBook empty = new GradeBook("BOS");
System.out.println(empty.classAverage() + " " + empty.topStudent());