Int Array als Übergabeparameter in getMethod

[Cheefrocker]

Hallo zusammen,

wie kann ich ein int[] Array als Übergabeparameter definieren? Die Methode getxy hat als übergabeparameter ein int[].
Ich weis nicht genau wie ich clazz.getMethod("getxy") bestücken soll.

Class<?> clazz = null; 

        try {
            clazz = Class.forName("AccountCRCAlgs");
            Object o = null; 
            try {
                o = clazz.newInstance();
            } catch (InstantiationException ex) {
                Logger.getLogger(CView.class.getName()).log(Level.SEVERE, null, ex);
            }
            try {
              //  clazz.getMethod("getxy").invoke(o,nr );
                showMethods(o);
                      Class[] parameterTypes = new Class[]{int.class}; 
               java.lang.reflect.Method method = clazz.getMethod( "method", parameterTypes );
            } catch (SecurityException ex) {
                Logger.getLogger(CView.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(CView.class.getName()).log(Level.SEVERE, null, ex);
        }

Besten dank im voraus!

 

[SlaterB]

hauptsache erstmal alles mit try/ catch vollkleistern, was?

public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        Class<?> clazz = Class.forName("Test");
        Object o = clazz.newInstance();
        Class[] parameterTypes = new Class[] {int[].class};
        Method method = clazz.getMethod("method", parameterTypes);
        method.invoke(o, new Object[] {new int[] {2, 3, 4}});
    }

    public void method(int[] x)
    {
        System.out.println("dummy: " + Arrays.toString(x));
    }
}

 

[Cheefrocker]

vielen dank @slaterb funzt..

try/catch ich sag nur autovervollständigung!

 

[Cheefrocker]

Eine Kleinigkeit habe ich noch.

Kann man die Funktionalität umbauen, sodass diese wie eine Art generische Klasse funktioniert.

Ziel: - klasse soll für andere Bereiche genutzt werden.
- Klassen/Methoden und übergabeparameter sollen universel eingesetzt werden können. Sprich für andere Klassen mit anderen Methoden übertragbar.

Hoffe ich habe mich verständlich ausgedrückt

 

[Cheefrocker]

sowas in der Art???

public class CClassForName<T> {
    
    public void setting(String klassennamen,String methodenname,T param) throws Exception
    {
       Class<?> clazz = null; 
       
        try {
            clazz = Class.forName(klassennamen);
            Object o = null; 
            try {
                o = clazz.newInstance();//Instanzieren des Objektes
            } catch (InstantiationException ex) {
              throw ex;
            }
            
            try {
               Class[] parameterTypes = new Class[]{param.getClass()};      
               
               java.lang.reflect.Method method = clazz.getMethod(methodenname, parameterTypes );
               
            } catch (SecurityException ex) {
               throw ex;
            }
        } catch (ClassNotFoundException ex) {
           throw ex;
        }
    }

Vielleicht hat einer eine gute Idee.

 

[SlaterB]

vielleicht meinst du sowas:

public class Test<T>
{

    public static void main(String[] args)
        throws Exception
    {
        Class<?> clazz = Class.forName("Test");
        Object o = new Test<String>();
        Method method = clazz.getMethod("set", new Class[] {Object.class});
        System.out.println(method+" - "+method.getParameterTypes()[0]);
        method.invoke(o, new Object[] {new Object()});


        clazz = Class.forName("TestT");
        o = clazz.newInstance();
        Method method1 = clazz.getMethod("set", new Class[] {String.class});
        Method method2 = clazz.getMethod("set", new Class[] {Object.class});
        System.out.println(method1+" - "+method1.getParameterTypes()[0]);
        System.out.println(method2+" - "+method2.getParameterTypes()[0]);
        method1.invoke(o, new Object[] {"hi"});
        method2.invoke(o, new Object[] {new Object()});
    }

    public void set(T t)
    {
        System.out.println("set: " + t);
    }
}


class TestT
    extends Test<String>
{
    @Override
    public void set(String t)
    {
        super.set(t);
        System.out.println(t.contains(""));
    }
}

--------

Ausgabe:
public void Test.set(java.lang.Object) - class java.lang.Object
set: java.lang.Object@182f0db
public void TestT.set(java.lang.String) - class java.lang.String
public volatile void TestT.set(java.lang.Object) - class java.lang.Object
set: hi
true
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:585)
	at Test.main(Test.java:23)
Caused by: java.lang.ClassCastException: java.lang.Object
	at TestT.set(Test.java:1)
	... 5 more

allgemein sehe ich aber wenig Sinn, Generics mit Reflection zu verknüpfen