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();
}
}
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
}
}
class DateObject {
boolean getLocalizationdate() {
// return true Or False according to business logic
}
}
class ObjectSpecificConditionGenerics<T extends DateObject> {
private T classTypeGenerics;
public boolean check(T genericsobj) {
genericsobj.getLocalizationdate();
}
}
