Dynamic Invocation

< Java Programming < Reflection

Navigate Reflection topic:

We start with basic transfer object:

Code listing 10.1: DummyTo.java 
 1 package com.test;
 2  
 3 public class DummyTo {
 4     private String name;
 5     private String address;
 6  
 7     public String getName() {
 8         return name;
 9     }
10  
11     public void setName(String name) {
12         this.name = name;
13     }
14  
15     public String getAddress() {
16         return address;
17     }
18  
19     public void setAddress(String address) {
20         this.address = address;
21     }
22  
23     public DummyTo(String name, String address) {
24         this.name = name;
25         this.address = address;
26     }
27  
28     public DummyTo() {
29         this.name = new String();
30         this.address = new String();
31     }
32  
33     public String toString(String appendBefore) {
34         return appendBefore + " " + name + ", " + address;
35     }
36 }

Following is the example for invoking method from the above mentioned to dynamically. Code is self explanatory.

Code listing 10.2: ReflectTest.java 
 1 package com.test;
 2  
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.InvocationTargetException;
 5 import java.lang.reflect.Method;
 6  
 7 public class ReflectTest {
 8     public static void main(String[] args) {
 9         try {
10             Class<?> dummyClass = Class.forName("com.test.DummyTo");
11  
12             // parameter types for methods
13             Class<?>[] partypes = new Class[]{String.class};
14  
15             // Create method object. methodname and parameter types
16             Method meth = dummyClass.getMethod("toString", partypes);
17  
18             // parameter types for constructor
19             Class<?>[] constrpartypes = new Class[]{String.class, String.class};
20  
21             //Create constructor object. parameter types
22             Constructor<?> constr = dummyClass.getConstructor(constrpartypes);
23  
24             // create instance
25             Object dummyto = constr.newInstance(new Object[]{"Java Programmer", "India"});
26  
27             // Arguments to be passed into method
28             Object[] arglist = new Object[]{"I am"};
29  
30             // invoke method!!
31             String output = (String) meth.invoke(dummyto, arglist);
32             System.out.println(output);
33  
34         } catch (ClassNotFoundException e) {
35             e.printStackTrace();
36         } catch (SecurityException e) {
37             e.printStackTrace();
38         } catch (NoSuchMethodException e) {
39             e.printStackTrace();
40         } catch (IllegalArgumentException e) {
41             e.printStackTrace();
42         } catch (IllegalAccessException e) {
43             e.printStackTrace();
44         } catch (InvocationTargetException e) {
45             e.printStackTrace();
46         } catch (InstantiationException e) {
47             e.printStackTrace();
48         }
49     }
50 }
Console for Code listing 10.2 
I am Java Programmer, India

Conclusion: Above examples demonstrate the invocation of method dynamically using reflection.

This article is issued from Wikibooks. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.