对“类型擦除”对象进行类型转换是否安全？

Question

A class (implementing a generic interface) has a method which returns java.lang.Object datatype instead of the expected. Is it safe to typecast it at the caller statement?

import java.io.*; 
import java.lang.*;

interface dataCharge<A>{
    public A change(A ele); 
}

class APCDcharge implements dataCharge<APCDcharge>{
    private String name;
    private Integer charge;
    public void setName(String name){
        this.name = name;
    }
    public void setCharge(Integer charge){
        this.charge = charge;
    }
    public String getName(){
        return name;
    }
    public Integer getCharge(){
        return charge;
    }
    public String getKey(){
        return name+":"+charge;
    }
    @Override
    public APCDcharge change(APCDcharge ele){
        APCDcharge newele = new APCDcharge();
        newele.setCharge(ele.getCharge()+100);
        newele.setName(ele.getName());
        return newele;
    }
}

public class Main {
    public static void main(String[] args) {
        APCDcharge c = new APCDcharge();
        c.setName("ABC");
        c.setCharge(100);
        APCDcharge d = timePass(c);
        System.out.println(d.getKey());
    }
    private static <T extends dataCharge> T timePass(T element){
        T res = element.change(element);
        return res;
    }
}

The above code snippet gives error :

error: incompatible types: Object cannot be converted to TT res = element.change(element);

I also tried typecasting element.change(element) with T datatype like :

T res = (T)element.change(element);

And the code is compiling (with a warning: Note: Main.java uses unchecked or unsafe operations. ), but executing correctly. Is that safe a way to remove the error? Is there any other way to correct it?

Answer 1

Your problem is that in your static method the type bound of T is a raw type ( dataCharge ).

Make the following change:

private static <T extends dataCharge<T>> T timePass(T element){
    T res = element.change(element);
    return res;
}

ie T extends dataCharge<T> instead of T extends dataCharge .

Now the code will pass compilation without the cast.

Answer 2

This method:

static <T extends dataCharge> T timePass(T element){
    T res = element.change(element);
    return res;
}

Uses a raw (ie untyped) dataCharge . You should type it, plus return the type of dataCharge , not the (sub)class of dataCharge .

Given way you have used it, which is to pass itself into its own method, suggests that dataCharge should be more simply defined with as a supplier of dataCharge and directly access its own state when creating the result:

interface dataCharge<A>{
    public A change(); 
}

class APCDcharge implements dataCharge<APCDcharge> {
    // other code

    @Override
    public APCDcharge change() {
    APCDcharge newele = new APCDcharge();
    newele.setCharge(getCharge()+100);
    newele.setName(getName());
    return newele;
    }
}

Then your timePass method then becomes:

static <T> T timePass(dataCharge<T> element){
    T res = element.change();
    return res;
}