将整数数组的StudentGrades类改造为Number泛型类的技术求助

原整数版本代码 #

import java.util.Arrays;

public class StudentGrades {
    private int grades[];
    private int pointer;
    private int max_grade;
    private int min_grade;
    private double average_grade;
    private int better_than_average;
    private int worse_than_average;
    private int excelent_count;
    private int good_count;
    private int enaught_count;

    public int getMax_grade() {
        return max_grade;
    }

    public int getMin_grade() {
        return min_grade;
    }

    public double getAverage_grade() {
        return average_grade;
    }

    public int getBetter_than_average() {
        return better_than_average;
    }

    public int getWorse_than_average() {
        return worse_than_average;
    }

    public int getExcelent_count() {
        return excelent_count;
    }

    public int getGood_count() {
        return good_count;
    }

    public int getEnough_count() {
        return enaught_count;
    }


    StudentGrades() {
        pointer = -1;
        grades = new int[1000];
        average_grade = 0;
        better_than_average = 0;
        worse_than_average = 0;
        excelent_count = 0;
        good_count = 0;
        enaught_count = 0;
        max_grade = 0;
        min_grade = 0;
    }

    private void calculate() {
        average_grade = 0;
        better_than_average = 0;
        worse_than_average = 0;
        excelent_count = 0;
        good_count = 0;
        enaught_count = 0;
        max_grade = 0;
        min_grade = 0;
        if (pointer < 0) return;
        double sum = 0;
        max_grade = grades[0];
        min_grade = grades[0];
        for (int i = 0; i <= pointer; i++) {
            sum += grades[i];
            if (grades[i] > max_grade)
                max_grade = grades[i];
            if (grades[i] < min_grade)
                min_grade = grades[i];
            if (grades[i] >= 91)
                excelent_count++;
            else if (grades[i] >= 71)
                good_count++;
            else if (grades[i] >= 60)
                enaught_count++;
        }
        average_grade = sum / (double) (pointer + 1);

        for (int i = 0; i <= pointer; i++) {
            if (grades[i] > average_grade)
                better_than_average++;
            else
                worse_than_average++;
        }
    }

    private boolean is_valid(int n) {
        return (n > 0 && n < 100);
    }

    public boolean setter(int marks[]) {
        for (int i = 0; i < marks.length; i++) {
            if (!is_valid(marks[i]))
                return false;
        }
        grades = marks;
        pointer = marks.length - 1;
        calculate();
        return true;
    }

    public boolean adder(int new_element) {
        if (!is_valid(new_element))
            return false;
        if (grades.length == pointer + 1) {
            int[] new_size_array = new int[grades.length * 2];
            for (int i = 0; i <= pointer; i++) new_size_array[i] = grades[i];
            grades = new_size_array;
        }
        pointer++;
        grades[pointer] = new_element;
        calculate();
        return true;
    }

    public int[] getter() {
        int[] result = new int[pointer + 1];
        for (int i = 0; i <= pointer; i++)
            result[i] = grades[i];
        return result;
    }

    public void to_string() {
        System.out.println(Arrays.toString(getter()));
    }
}

泛型版本的核心错误点 #

1. 字段类型错误：计数类字段（better_than_average、excelent_count等）不需要用泛型E，它们是统计数量，应该用int；平均值average_grade应为double（避免整数除法丢失精度）。
2. 泛型约束不足：仅继承Comparable<E>无法支持数值运算（求和、求平均），需要同时约束E为Number的子类。
3. 数值运算错误：泛型类型不能直接使用+、/、>等运算符，必须先转换为数值类型（如double）后再计算。
4. 阈值比较错误：不能直接将泛型E与整数（91、71、60）比较，需提取E的数值后再对比。
5. 数组初始化问题：无参构造中用Comparable[]强转为E[]会导致运行时类型转换异常，应使用反射创建正确类型的数组。
6. Number抽象方法未实现：继承Number后未重写抽象方法的实际逻辑，仅返回默认值0。

修正后的完整泛型代码 #

import java.util.Arrays;
import java.lang.reflect.Array;

public class StudentGradesGeneric<E extends Number & Comparable<E>> extends Number {
    private E[] grades;
    private int pointer;
    private E max_grade;
    private E min_grade;
    private double average_grade;
    private int better_than_average;
    private int worse_than_average;
    private int excelent_count;
    private int good_count;
    private int enaught_count;
    private final Class<E> type;

    // 带类型和初始容量的构造方法
    public StudentGradesGeneric(Class<E> type, int capacity) {
        this.type = type;
        this.grades = (E[]) Array.newInstance(type, capacity);
        this.pointer = -1;
        resetStats();
    }

    // 无参构造，默认初始容量1000，默认类型为Integer（兼容原代码逻辑）
    public StudentGradesGeneric() {
        this((Class<E>) Integer.class, 1000);
    }

    // 重置统计字段
    private void resetStats() {
        average_grade = 0.0;
        better_than_average = 0;
        worse_than_average = 0;
        excelent_count = 0;
        good_count = 0;
        enaught_count = 0;
        max_grade = null;
        min_grade = null;
    }

    @Override
    public int intValue() {
        return (int) average_grade;
    }

    @Override
    public long longValue() {
        return (long) average_grade;
    }

    @Override
    public float floatValue() {
        return (float) average_grade;
    }

    @Override
    public double doubleValue() {
        return average_grade;
    }

    private void calculate() {
        resetStats();
        if (pointer < 0) return;

        double sum = 0.0;
        max_grade = grades[0];
        min_grade = grades[0];

        // 第一轮遍历：求和、找最大最小值、统计等级数量
        for (int i = 0; i <= pointer; i++) {
            E grade = grades[i];
            double gradeValue = grade.doubleValue();
            sum += gradeValue;

            // 更新最大最小值
            if (grade.compareTo(max_grade) > 0) {
                max_grade = grade;
            }
            if (grade.compareTo(min_grade) < 0) {
                min_grade = grade;
            }

            // 统计等级
            if (gradeValue >= 91) {
                excelent_count++;
            } else if (gradeValue >= 71) {
                good_count++;
            } else if (gradeValue >= 60) {
                enaught_count++;
            }
        }

        // 计算平均值
        average_grade = sum / (pointer + 1);

        // 第二轮遍历：统计高于/低于平均值的数量
        for (int i = 0; i <= pointer; i++) {
            double gradeValue = grades[i].doubleValue();
            if (gradeValue > average_grade) {
                better_than_average++;
            } else {
                worse_than_average++;
            }
        }
    }

    private boolean is_valid(E n) {
        double value = n.doubleValue();
        return value > 0 && value < 100;
    }

    public boolean setter(E[] marks) {
        for (E mark : marks) {
            if (!is_valid(mark)) {
                return false;
            }
        }
        // 用反射创建同类型数组，避免直接赋值外部数组导致的修改风险
        this.grades = (E[]) Array.newInstance(type, marks.length);
        System.arraycopy(marks, 0, this.grades, 0, marks.length);
        this.pointer = marks.length - 1;
        calculate();
        return true;
    }

    public boolean adder(E new_element) {
        if (!is_valid(new_element)) {
            return false;
        }

        // 数组扩容
        if (pointer + 1 == grades.length) {
            E[] newGrades = (E[]) Array.newInstance(type, grades.length * 2);
            System.arraycopy(grades, 0, newGrades, 0, grades.length);
            grades = newGrades;
        }

        pointer++;
        grades[pointer] = new_element;
        calculate();
        return true;
    }

    public E[] getter() {
        E[] result = (E[]) Array.newInstance(type, pointer + 1);
        System.arraycopy(grades, 0, result, 0, pointer + 1);
        return result;
    }

    public void to_string() {
        System.out.println(Arrays.toString(getter()));
    }

    // Getter方法
    public E getMax_grade() {
        return max_grade;
    }

    public E getMin_grade() {
        return min_grade;
    }

    public double getAverage_grade() {
        return average_grade;
    }

    public int getBetter_than_average() {
        return better_than_average;
    }

    public int getWorse_than_average() {
        return worse_than_average;
    }

    public int getExcelent_count() {
        return excelent_count;
    }

    public int getGood_count() {
        return good_count;
    }

    public int getEnough_count() {
        return enaught_count;
    }
}

关键修正说明 #

• 泛型约束：使用E extends Number & Comparable<E>，确保类型既支持数值运算又支持比较。
• 字段类型调整：计数类字段改为int，平均值改为double，符合统计逻辑。
• 数值运算处理：所有泛型数值先通过doubleValue()转换为double后再进行计算和比较。
• 数组操作优化：使用反射创建正确类型的数组，避免类型转换异常；使用System.arraycopy提高数组复制效率。
• Number方法实现：基于平均值返回对应数值类型，符合Number类的设计意图。

内容的提问来源于stack exchange，提问作者Nadia