В следующем примере показано, как обращаться к методам динамически с помощью отражения.


import java.lang.reflect.*;

import java.io.*;



public class testReflect {

   public static void main(String s[]) {

      testReflect t = new testReflect();

      try {

         t.doit();

         }

      catch (Exception e) {

         e.printStackTrace();

         }

      }

   public void doit() throws Exception {

      String aClass;

      String aMethod;   

      // we assume that called methods have no argument

      Class params[] {};

      Object paramsObj[] {};

      

      while (true) {

         /* examples 

            Class: class1         Method: class1Method2

            Class: java.util.Date Method: toString

            Class: java.util.Date Method: getTime

         */

         aClass  = Input.Line("\nClass : ");

         aMethod = Input.Line("Method: ");

         // get the Class

         Class thisClass = Class.forName(aClass);

         // get an instance 

         Object iClass = thisClass.newInstance();

         // get the method

         Method thisMethod = thisClass.getDeclaredMethod(aMethod, params);

         // call the method

         System.out.println(thisMethod.invoke(iClass, paramsObj).toString());

         }

      }

   

   static class Input {

     public static String Line(String sthrows IOException {

         BufferedReader input = 

             new BufferedReader(new InputStreamReader(System.in));

         System.out.print(s);

         return input.readLine();     

        }

     }

}



class class1 {

   public String class1method1() {

      return "*** Class 1, Method1 ***";

      }

   public String class1method2() {

      return "### Class 1, Method2 ###";

      }

}

Следующий пример вызывает метод класса с 2 аргументами:


import java.lang.reflect.*;



public class TestReflect {

  static void invoke(String aClass, String aMethod, Class[] params, Object[] args) {

    try {

      Class c = Class.forName(aClass);

      Method m = c.getDeclaredMethod(aMethod, params);      

      Object i = c.newInstance();

      Object r = m.invoke(i, args);

      

    catch (Exception e) {

      e.printStackTrace();

      

    }



  public static void main(String[] args) {

    invoke("Class1""say"new Class[] {String.class, String.class}

           new Object[] 

             {new String("Hello")new String("World")});

    }

}



class Class1 {

  public void sayString s1, String s2) {

    System.out.println(s1 + " " + s2);

    }

}   

Рефлексия мощный подход к анализу классов во время исполнения. Если новые классы добавить в ваше приложение динамического отражения затем используется для получения структуры класса.

Отражения используются специальные виды Java-класса: класс. Объект класса типа может содержать всю информацию о классе и геттер методы получения этой информации.

Этот пример кода извлекает структуре класса String. Он будет отображать имя конструкторов, заявил поля и методы к консоли.


import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class ReflectionExample {



  public static void main(String[] args) {

    try {

      // Creates an object of type Class which contains the information of 

      // the class String

      Class cl = Class.forName("java.lang.String");



      // getDeclaredFields() returns all the constructors of the class.

      Constructor cnst[] = cl.getConstructors();



      // getFields() returns all the declared fields of the class.

      Field fld[] = cl.getDeclaredFields();



      // getMethods() returns all the declared methods of the class.

      Method mtd[] = cl.getMethods();

      System.out.println("Name of the Constructors of the String class");



      for (int i = 0; i < cnst.length; i++) {

        System.out.println(cnst[i].getName());

      }



      System.out.println("Name of the Declared fields");



      for (int i = 0; i < fld.length; i++) {

        System.out.println(fld[i].getName());

      }



      System.out.println("Name of the Methods");



      for (int i = 0; i < mtd.length; i++) {

        System.out.println(mtd[i].getName());

      }



    catch (ClassNotFoundException e) {

      e.printStackTrace();

    }

  }



}

Отражения используется для вызова метода, когда имя метода поставляется во время выполнения. Этот совет будет показывать пример кода для этого.


import java.lang.reflect.Method;



public class RunMthdRef {

  public int add(int a, int b) {

    return a+b;

  }



  public int sub(int a, int b) {

    return a-b;

  }



  public int mul(int a, int b) {

    return a*b;

  }



  public int div(int a, int b) {

    return a/b;

  }



  public static void main(String[] args) {

    try {

      Integer[] input={new Integer(2),new Integer(6)};

      Class cl=Class.forName("RunMthdRef");

      Class[] par=new Class[2];

      par[0]=Integer.TYPE;

      par[1]=Integer.TYPE;

      Method mthd=cl.getMethod("add",par);

      Integer output=(Integer)mthd.invoke(new RunMthdRef(),input);

      System.out.println(output.intValue());

    catch (Exception e) {

      e.printStackTrace();

    

  }

}