java之反射

反射能获取一切信息

类的名称，包括包名和类名，可以通过调用Class对象的getName()和getSimpleName()方法获取。

1. 类的属性，包括公共属性和私有属性，可以使用Class对象的getFields()和getDeclaredFields()方法获取。如果属性是私有的，可以使用getDeclaredField()方法获取。
2. 类的方法，包括公共方法和私有方法，可以使用Class对象的getMethods()和getDeclaredMethods()方法获取。如果方法需要特定的参数类型，可以使用getMethod()方法传入参数类型获取。
3. 类的构造器，可以使用Class对象的getConstructors()和getDeclaredConstructors()方法获取。

反射类信息的三种方式：

①Class.forName()：这是最常见的反射方式，用于获取指定类的Class对象。例如，Class.forName("java.util.ArrayList")会返回java.util.ArrayList类的Class对象。

②对象.getClass()方法：当你有一个对象，但不知道它的类型时，可以使用getClass()方法获取其Class对象。例如，ArrayList list = new ArrayList();，那么list.getClass()会返回java.util.ArrayList类的Class对象。

③类.class方法：对于直接类，可以通过.class获取Class对象。例如，ArrayList.class会返回java.util.ArrayList类的Class对象。

package 反射;

import java.lang.reflect.*;
import java.util.*;

public class TestRelect {
    
    public static void main(String[] args) {
        String name = "反射.Reflection";
        
        try {
            //print class name and superclass(if != Object)
            Class cl = Class.forName(name);
            Class supercl = cl.getSuperclass();
            String modifiers = Modifier.toString(cl.getModifiers());
            if(modifiers.length()>0) {
                System.out.print(modifiers+" ");
            }
            System.out.print("class "+name);
            if(supercl != null && supercl != Object.class) {
                System.out.print(" extends "+supercl.getName());
            }
            System.out.print("\n{\n");
            printConstructors(cl);
            System.out.println();
            printMethods(cl);
            System.out.println();
            printFields(cl);
            System.out.println("}");
        }
        catch(ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }
    
    /**
     * Prints all constructors of a class
     * @param cl a class
     */
    public static void printConstructors(Class cl) {
        Constructor[] constructors = cl.getDeclaredConstructors();
        
        for(Constructor c:constructors) {
            String name = c.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(c.getModifiers());
            if(modifiers.length()>0) {
                System.out.print(modifiers+" ");
            }
            System.out.print(name+"(");
            
            //print parameter types
            Class[] paramTypes = c.getParameterTypes();
            for(int j=0; j<paramTypes.length;j++) {
                if(j>0) {
                    System.out.print(", ");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }
    
    /**
     * Prints all methods of a class
     * @param cl a class
     */
    public static void printMethods(Class cl) {
        Method[] methods = cl.getDeclaredMethods();
        
        for(Method m:methods) {
            Class retType = m.getReturnType();
            String name = m.getName();
            
            System.out.print("  ");
            String modifiers = Modifier.toString(m.getModifiers());
            if(modifiers.length()>0) {
                System.out.print(modifiers+" ");
            }
            System.out.print(retType.getName()+" "+name+"(");
            
            //print parameter types
            Class[] paramTypes = m.getParameterTypes();
            for(int j=0; j<paramTypes.length;j++) {
                if(j>0) {
                    System.out.print(", ");
                }
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }
    
    /**
     * Prints all fields of a class
     * @param cl a class
     */
    public static void printFields(Class cl) {
        Field[] fields = cl.getDeclaredFields();
        
        for(Field f:fields) {
            Class type = f.getType();
            String name = f.getName();
            System.out.print("  ");
            String modifiers = Modifier.toString(f.getModifiers());
            if(modifiers.length()>0) {
                System.out.print(modifiers+" ");
            }
            System.out.println(type.getName()+" "+name+";");
        }
    }
}

 =================================================================
 输出：
 public class 反射.Reflection
{
  public 反射.Reflection();
  public 反射.Reflection(int, java.lang.String);

  public void m2(int, float);
  public void m1(int, float);
  public static void m3(int, double, float);

  private int age;
  public java.lang.String name;
  public static final int WW;
}

package 反射;

public class Reflection {
    private int age;
    public String name;
    public static final int WW = 90;
    public Reflection() {
        
    }
    public Reflection(int xx, String yy) {
        
    }
    
    public void m1(int aa, float bb) {
        
    }
    
    public void m2(int aa, float bb) {
        
    }
    public static void m3(int aa, double nn, float bb) {
        
    }
}

在Java中，getDeclaredMethod和getMethod都是用于获取类中的方法，但是它们之间存在一些重要的区别。

访问控制：

getDeclaredMethod方法用于获取类中声明的所有方法，包括public、protected和private方法。

getMethod方法用于获取类中的public方法，不包括protected和private方法。

方法名称：

getDeclaredMethod方法需要传递方法名称作为参数，如果方法名称不匹配或方法不存在，它将抛出NoSuchMethodException异常。

getMethod方法也需要传递方法名称作为参数，但它只会返回第一个匹配的public方法。如果找不到匹配的方法，它将抛出NoSuchMethodException异常。

参数列表：

getDeclaredMethod方法需要传递一个参数类型数组作为第二个参数，用于指定要调用的方法的参数类型。如果传递的参数类型不匹配方法参数类型，它将抛出IllegalArgumentException异常。

getMethod方法不需要传递参数类型数组，因为它只查找public方法，并且使用方法的默认参数类型。如果传递的参数类型不匹配方法的默认参数类型，它将抛出IllegalArgumentException异常。

返回值类型：

getDeclaredMethod方法返回一个Method对象，可以用于进一步的方法调用和操作。

getMethod方法返回一个Method对象，也可以用于进一步的方法调用和操作。

总结：getDeclaredMethod和getMethod都是用于获取类中的方法，但是它们的应用场景有所不同。如果需要获取类中声明的所有方法，包括private和protected方法，请使用getDeclaredMethod。如果只需要获取类中的public方法，并且不需要考虑方法的访问控制，请使用getMethod。