当双变量被转换为泛型类型T时，如何抛出ClassCastException？

Question

我正在实现一个泛型类LabelEncoder

/**
 * Encodes target labels with value between 0 and n_classes-1.
 * If T is comparable, this class supports encoding by "natural-order" or by "index-order".
 * Otherwise, this class only supports encoding by "index-order".
 *
 * @param <T> the Java Class of labels
 * @author Cloudy1225
 */
public class LabelEncoder <T> extends Encoder<T>{

    /**
     * Holds the mapping between labels and encodings.
     */
    public Map<T, Double> encodingMap;

    /**
     * Whether this encoder has already been fitted.
     */
    private boolean fitted;


    /**
     * Creates a LabelEncoder.
     */
    public LabelEncoder() {}

    /**
     * Fits the label encoder by "natural-order" or by "index-order".
     *
     * @param labels a double array of target values.
     * @param natural true: encode by "natural-order"; false: encode by "index-order"
     * @throws ClassCastException if the generic type of this class is not Double
     */
    public void fit(double[] labels, boolean natural) {
        this.reset(natural);
        Double encoding = 0.0;
        for (Double label: labels) {
************T l = (T) label;************
            Double oldValue = this.encodingMap.put(l, encoding);
            if (oldValue == null) { // It denotes that the label hadn't been in the map.
                encoding++;
            }
        }
        this.fitted = true;
    }

     /**
     * Fits the label encoder by "natural-order" or by "index-order".
     * If given labels are not comparable, "natural" will be automatically set false.
     *
     * @param labels an array of target values.
     * @param natural true: encode by "natural-order"; false: encode by "index-order"
     */
    public void fit(T[] labels, boolean natural) {
        if (!(labels instanceof Comparable[])) {
            natural = false;
        }
        this.reset(natural);
        Double encoding = 0.0;
        for (T label: labels) {
            Double oldValue = this.encodingMap.put(label, encoding);
            if (oldValue == null) { 
                encoding++;
            }
        }
        this.fitted = true;
    }

     /**
     * Resets or initializes before being fitted.
     *
     * @param natural true: encode by "natural-order"; false: encode by "index-order"
     */
    private void reset(boolean natural) {
        // Sorting is implemented by TreeMap or by LinkedHashMap.
        if (natural) {
            this.encodingMap = new TreeMap<T, Double>();
        } else {
            this.encodingMap = new LinkedHashMap<T, Double>();
        }
        this.fitted = false;
    }

    public static void main(String[] args) {
        LabelEncoder<String> encoder = new LabelEncoder<>();
        encoder.fit(new double[] {3,4,5}); // It's expected that a ClassCastException will be thrown here.
        Map<String, Double> map = encoder.encodingMap;
        System.out.println(map);
    }
}

测试结果如下：

{3.0=0.0, 4.0=1.0, 5.0=2.0}

那么如何在执行T l=（T）标签时抛出ClassCastException；？

提前感谢！




Answer 1

由于您正在执行new Double[]{3,4,5}，因此您正在进行隐式的双精度强制转换，因此您实际上是在向方法传递一个双精度数组，因此您不能期望出现ClassCastException。此外，您不能期望从强制转换到泛型的Exception是完全合法的强制转换。如果您想抛出异常，您应该尝试以下内容：

if(!(label instanceof Double))
    throw new Exception("Not a Double");

请进一步详细说明您试图实现的目标，因为我不清楚。