Detailed explanation of reflection mechanism containing array parameters in Java

This article mainly introduces relevant information about the reflection mechanism (including array parameters) in Java. I hope this article can help everyone understand and master this part of the content. Friends in need can refer to it

Detailed explanation of the reflection mechanism in java (including array parameters)

The reflection of java is something I have always liked very much, because with this, the flexibility of the program can be greatly increased, and at the same time The versatility has also been improved a lot. I don’t want to introduce the principle of reflection in a big way. Just search on the Internet and you’ll find a lot of them. (I will only introduce it in the appendix below)

Reflection is a key property of Java being regarded as a dynamic (or quasi-dynamic) language. This mechanism allows the program to obtain the internal information of any class with a known name through the Reflection APIs at runtime, including its modifiers (such as public, static, etc.), superclass (such as Object), implemented interfaces (such as Cloneable), and Includes all information about fields and methods, and can change the contents of fields or invoke methods at runtime

Here, what I want to say is that if we do what we want based on strings (including dynamic execution of correspondence method, generate the corresponding class), when we transmit data, most of them pass strings (HTTP, socket), etc. When we receive these strings, we will do the corresponding actions based on the contents of these strings. thing, that is a very good thing, you can call methods remotely (the client sends a specified string, and let the server execute the corresponding method based on reflection). . . In fact, I have also worked on such a project. The client (not written in Java language) uses socket to call the server (written in Java) method, and can also directly pass parameters. These are all implemented based on Java's reflection technology. Okay, let’s not talk about the rest. Let’s start with the most basic ones. The following is a most basic method reflection

/**
 * @(#)TestInt.java
 *
 * @author soda E-mail:sujun10@21cn.com
 * @version 1.0
 * <br>Copyright (C), 2007 soda.C
 * <br>This program is protected by copyright laws.
 * <br>Date:2007.4
 */
import java.lang.reflect.Method;

public class TestInt
{
  //测试方法
  public String test(String name,int i)
  {
    System.out.println("name:" + name);
    System.out.println(i);
    return "反射成功!";
  }

  public static void main(String[] args)
  {
    try
    {
      //获取class文件，可以Class.for("Test")获取，这样也可以根据字符串生成类啦
      Class te = TestInt.class;
      Class[] cl = new Class[2];
      //添加参数类型
      cl[0] = String.class;
      cl[1] = int.class;
      System.out.println("11111111");
      //根据public的方法，以及参数，参数是Class[]形式
      Method method = te.getMethod("test", cl);
      System.out.println("222222222222");
      //开始填充参数
      Object[] params = new Object[2];
      //params[0] = new String("soda");
      params[0] = new String("soda");
      params[1] = new Integer(23);
      System.out.println("22222222222");
      //获取该class的实例
      Object obj = te.newInstance();
      //进行方法调用
      Object result = method.invoke(obj, params);
      System.out.println("结果:" + result);
    }
    catch (Exception e)
    {
      System.out.println(e);
    }

  }
}

Compile and execute, you can see what you want The result, imagine turning those strings into data passed from other places:)

Another method has array reflection. I studied it and found that there is a slight difference. Everyone should read it carefully

/**
 * @(#)Test.java
 *
 * @author soda E-mail:sujun10@21cn.com
 * @version 1.0
 * <br>Copyright (C), 2007 soda.C
 * <br>This program is protected by copyright laws.
 * <br>Program Name:FlashSyncServer
 * <br>Date:2007.1
 */
import java.lang.reflect.Method;
//这里我就不做什么解释了，和前面的几乎一样，大家也可以自己去查查api，Class类的api
public class Test
{
  public void test(double[] dou)
  {
    System.out.println(dou.length);
    System.out.println(dou[0]);
  }
  public static void main(String[] args) throws Exception
  {
    try
    {
      Class[] cl = new Class[1];
      cl[0] = double[].class;
      System.out.println("cl[0]:" + cl[0]);
      Object[] in = new Object[1];
      //注意这里，不是Double[]，而是double[]。这里不能用对象数组
      double[] db = new double[1];
      db[0] = 100.0;
      in[0] = db;
      Class te = Test.class;
      Method method = te.getMethod("test", cl);
      Object obj = te.newInstance();
      Object objs = method.invoke(obj, in);
    }
    catch (Exception e)
    {
      System.out.println(e);
    }

  }
}

Okay, the basics are like this, no matter how complex the program is, it has evolved from a foundation. I learned a lot here:)

The above is the detailed content of Detailed explanation of reflection mechanism containing array parameters in Java. For more information, please follow other related articles on the PHP Chinese website!