[JAVA] Come riconoscere una classe astratta da codice (a runtime)

[00kanly]

Ciao a tutti,
sto cercando di fare una funzione che verifichi il corretto funzionamento dei metodi di una classe, mi sono ispirato all'esempio che la sun fà nel tutorial relativo alle annotations.
Ampliando il loro esempio sono riuscito a "risolvere" i problemi relativi alle funzioni che richiedono come parametri tipi di dati primitivi o interfacce. Mi rimane ora il problema delle classi astratte... c'è un metodo analogo ad isPrimitive() o isInterface() per riconoscerle?

Vi posto qui il codice anche se è in via di sviluppo ed è ètutt'altro che pulito:

public static void main(String[] args) throws Exception {
		
		int passed = 0, failed = 0;
		String classeDaTestare="myapp.tester.prova";
		Class testClass=Class.forName(classeDaTestare);
		Object testObject=testClass.newInstance();
		for (Method m : Class.forName(classeDaTestare).getMethods()) {
			if (m.isAnnotationPresent(Test.class)) {
				Class[] parametri = m.getParameterTypes(); // parametri della funzione
				Object[] param = new Object[parametri.length];
				Annotation[][] noteParam=m.getParameterAnnotations();
				int i = 0;
				for (Class par : parametri) {
					System.out.println(par.getName());
					
					if (!par.isPrimitive()&&!par.isInterface()) {
						param[i] = par.newInstance();
						if (par.isInstance(TestInterface.class)&& testValueIndex(noteParam[i])!=-1) {
							((TestInterface) param[i]).setTestValues( ((TestValue)noteParam[i][testValueIndex(noteParam[i])]).value() );
						}
					}else if(par.isPrimitive()){
						String testVal="0";
						if (testValueIndex(noteParam[i])!=-1){
							testVal=((TestValue)noteParam[i][testValueIndex(noteParam[i])]).value();
						}
						if (par.getName().equals("byte")){
							param[i]=Byte.parseByte(testVal);
						}else if (par.getName().equals("short")){
							param[i]=Short.parseShort(testVal);
						}else if (par.getName().equals("int")){
							param[i]=Integer.parseInt(testVal);
						}else if (par.getName().equals("long")){
							param[i]=Long.parseLong(testVal);
						}else if (par.getName().equals("float")){							
							param[i]=Float.parseFloat(testVal);							
						}else if (par.getName().equals("double")){
							param[i]=Double.parseDouble(testVal);
						}else if (par.getName().equals("boolean")){
							if ("0".equals(testVal)) testVal="false";
							param[i]=Boolean.parseBoolean(testVal);
						}else if (par.getName().equals("char")){
							param[i]=testVal.charAt(0);
						}					
					}else{ //interface
						param[i]=null;
					}	
					i++;
				}
				try {
					m.invoke(testObject, param);
					passed++;
				} catch (Throwable ex) {
					ex.printStackTrace();
					System.out.printf("Test %s failed: %s %n", m, ex.getCause());
					failed++;
				}
			}
		}
		System.out.printf("Passed: %d, Failed %d%n", passed, failed);
	}
	
	private static int testValueIndex(Annotation [] ann){
		int i=0;
		for (Annotation k:ann){
			if (k.annotationType().equals(TestValue.class)){
				return i;
			}
			i++;
		}
		return -1;
	}

___________________________________

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {}

__________________________________

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface TestValue {
	String value();
}

Come vedete ci sono soluzioni "arrabattate" ma se nei metodi che testo non ci sono tipi astratti come parametri tutto funziona, altrimenti la jvm non gradisce il tentativo di istanziare una abstract class.... giustamente direi.

[andbin]

Originariamente inviato da 00kanly
Mi rimane ora il problema delle classi astratte... c'è un metodo analogo ad isPrimitive() o isInterface() per riconoscerle?

Vedi il metodo getModifiers() di Class e vedi anche isAbstract() di java.lang.reflect.Modifier.

[00kanly]

Grazie mille, era da un po che ci sbattevo la testa! ero arrivato a pensare di farlo con le eccezioni...