In-depth understanding 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 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

[Recommended learning: java video tutorial]

Here, I want to What it means is that if we do what we want based on strings (including dynamically executing corresponding methods and generating corresponding classes), when we transmit data, most of them pass strings (HTTP, socket), etc. , when we receive these strings, we will do corresponding things based on the contents of these strings. That is a very good thing. We can call methods remotely (the client sends the specified string and let the server execute it based on reflection. corresponding method). . .

In fact, I have also done 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 based on Java Realized by reflection technology. Okay, let’s talk about the rest. Let’s start with the most basic ones. The following is a basic method of 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 the desired results. Imagine putting those characters The string becomes 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.

This article comes from the java introduction column, welcome to learn!

The above is the detailed content of In-depth understanding of the reflection mechanism in Java (including array parameters). For more information, please follow other related articles on the PHP Chinese website!