Java框架中使用的具有编译时的泛型与具有类类型的运行时

Question

我写了三个程序，一个使用泛型，另一个不使用泛型

使用isAssignableFrom

public class ObjectSpecificCondition {
    private Class classType;

    public boolean check(Object obj) {
        boolean check = ((DateObject) obj).getLocalizationdate();
    }

    public ObjectSpecificCondition(Class classType) {
        this.classType = classType;
    }

    boolean checkTypeSpecific(Object busineesObject) {
        if (classType.isAssignableFrom(busineesObject.getClass())) {
            return true;
        }
        else{
            throw new Exception();
        }

    }

使用instanceOf

class ObjectSpecificCondition1 {

    public boolean check(Object busineesObject) {
        boolean check ;

        if(busineesObject instanceof DateObject){
            check= ((DateObject) busineesObject).getLocalizationdate();
        }
        else{
             throw new IllegalArgumentException();
        }
        return check;
    }

    }

使用泛型

class ObjectSpecificConditionGenerics<T extends DateObject> {
    private T classTypeGenerics;

    public boolean check(T genericsobj) {
        genericsobj.getLocalizationdate();

    }

}

业务对象规则

class DateObject {
    boolean getLocalizationdate() {
        // return true Or False according to business logic
    }
}

Main test
 public static void main(String[] args) throws Exception {
        DateObject mockdateObject = new DateObject();
        // caseI: No generics used caseI works fine no exception is generated but more lines of code to write
        ObjectSpecificCondition mockanalysis = new ObjectSpecificCondition(DateObject.class);

        if (mockanalysis.checkTypeSpecific(mockdateObject)) {
            mockanalysis.check(mockdateObject);

        }
     // caseII:No generics used caseII throws exception in run time .More lines of code to write.It can not capture incompatible type at compile time 
        ObjectSpecificCondition mockanalysis1 = new ObjectSpecificCondition(String .class);
        DateObject mockdateObject1 = new DateObject();
        if (mockanalysis.checkTypeSpecific(mockdateObject1)) {
            mockanalysis.check(mockdateObject1);

        }
       // caseIII;Generics used and line of code is reduced to less 
        ObjectSpecificConditionGenerics mockgenerics=new ObjectSpecificConditionGenerics() ;
        mockgenerics.check(mockdateObject);

        // caseIV;Generics used and line of code is reduced to less and error for compataible object is generated at compile time 
        ObjectSpecificConditionGenerics mockgenerics1=new ObjectSpecificConditionGenerics() ;
        String mockstring=new String();
        mockgenerics.check(mockstring); // it is captured at compile time ,i think its good to catch at compile time then to pass it at run time 

    }
}

我在框架中看到使用三种方法。我想更多地确定哪种方法是最好的？使用泛型的代码较少，并且在编译时可能会产生错误。但是，另一种方法也更有用。我想得到更深入的答案。请任何帮助

Answer 1

通用版本和非通用版本应该相同，唯一的区别是类型参数和类型转换。 非通用版本应该是通用版本的类型擦除 。 通过应用类型擦除转换，可以将任何通用代码转换为等效的非通用代码。

不使用泛型

public class ObjectSpecificCondition {
    private Class classType;

    public boolean check(DateObject obj) {
        boolean check = obj.getLocalizationdate();
    }

    public ObjectSpecificCondition(Class classType) {
        this.classType = classType;
    }

    boolean checkTypeSpecific(Object busineesObject) {
        if (classType.isInstance(busineesObject)) {
            return true;
        }
        else{
            throw new Exception();
        }

    }
}

使用泛型

public class ObjectSpecificCondition<T extends DateObject> {
    private Class<T> classType;

    public boolean check(T obj) {
        boolean check = obj.getLocalizationdate();
    }

    public ObjectSpecificCondition(Class<T> classType) {
        this.classType = classType;
    }

    boolean checkTypeSpecific(Object busineesObject) {
        if (classType.isInstance(busineesObject)) {
            return true;
        }
        else{
            throw new Exception();
        }

    }
}