从java文档页面

java.lang.reflect包提供了用于获取关于类和对象的反射信息的类和接口。反射允许编程访问有关已加载类的字段、方法和构造函数的信息，以及在安全限制内使用反射字段、方法或构造函数对其底层对应对象进行操作。

如果必要的ReflectPermission可用，AccessibleObject允许禁止访问检查。

此包中的类与java.lang.Class一起容纳调试器、解释器、对象检查器、类浏览器等应用程序，以及需要访问目标对象的公共成员（基于其运行时类）或给定类声明的成员的服务（如object Serialization和JavaBeans）

它包括以下功能。

获取类对象，检查类（字段、方法、构造函数）的财产，设置和获取字段值，调用方法，创建对象的新实例。

查看Class类公开的方法的文档链接。

本文（由Sosnoski Software Solutions，Inc总裁Dennis Sosnosiki撰写）和本文（security-explorations pdf）：

与使用反射相比，我可以看到相当多的缺点

反射用户：

它提供了动态链接程序组件的多种方式它对于创建以非常通用的方式处理对象的库非常有用

反射的缺点：

当用于字段和方法访问时，反射比直接代码慢得多。它可以隐藏代码中的实际情况它绕过源代码会产生维护问题反射代码也比相应的直接代码更复杂它允许违反关键Java安全约束，例如作为数据访问保护和类型安全

一般滥用：

加载限制类，获取对受限类的构造函数、方法或字段的引用，创建新的对象实例、方法调用、获取或设置受限类的字段值。

看看这个关于滥用反射功能的SE问题：

如何在Java中读取私有字段？

摘要：

在系统代码中不安全地使用其功能也很容易导致Java安全模型的破坏。因此，谨慎使用此功能

我只是想对所有列出的内容补充几点。

使用反射API，您可以为任何对象编写通用的toString（）方法。

它可能对调试有用。

以下是一些示例：

class ObjectAnalyzer {

   private ArrayList<Object> visited = new ArrayList<Object>();

   /**
    * Converts an object to a string representation that lists all fields.
    * @param obj an object
    * @return a string with the object's class name and all field names and
    * values
    */
   public String toString(Object obj) {
      if (obj == null) return "null";
      if (visited.contains(obj)) return "...";
      visited.add(obj);
      Class cl = obj.getClass();
      if (cl == String.class) return (String) obj;
      if (cl.isArray()) {
         String r = cl.getComponentType() + "[]{";
         for (int i = 0; i < Array.getLength(obj); i++) {
            if (i > 0) r += ",";
            Object val = Array.get(obj, i);
            if (cl.getComponentType().isPrimitive()) r += val;
            else r += toString(val);
         }
         return r + "}";
      }

      String r = cl.getName();
      // inspect the fields of this class and all superclasses
      do {
         r += "[";
         Field[] fields = cl.getDeclaredFields();
         AccessibleObject.setAccessible(fields, true);
         // get the names and values of all fields
         for (Field f : fields) {
            if (!Modifier.isStatic(f.getModifiers())) {
               if (!r.endsWith("[")) r += ",";
               r += f.getName() + "=";
               try {
                  Class t = f.getType();
                  Object val = f.get(obj);
                  if (t.isPrimitive()) r += val;
                  else r += toString(val);
               } catch (Exception e) {
                  e.printStackTrace();
               }
            }
         }
         r += "]";
         cl = cl.getSuperclass();
      } while (cl != null);

      return r;
   }    
}

Java反射非常强大，非常有用。Java反射使得在运行时检查类、接口、字段和方法成为可能，而不需要在编译时知道类、方法等的名称。还可以使用反射实例化新对象、调用方法和获取/设置字段值。

一个快速的Java反射示例，向您展示使用反射的样子：

Method[] methods = MyObject.class.getMethods();

    for(Method method : methods){
        System.out.println("method = " + method.getName());
    }

此示例从名为MyObject的类中获取Class对象。该示例使用类对象获取该类中方法的列表，迭代方法并打印出它们的名称。

这里解释了这一切的确切原理

编辑：差不多一年后，我在编辑这个答案，因为在阅读反思时，我很少再使用反思。

Spring使用bean配置，例如：

<bean id="someID" class="com.example.Foo">
    <property name="someField" value="someValue" />
</bean>

当Spring上下文处理这个＜bean＞元素时，它将使用Class.forName（String）和参数“com.example.Foo”来实例化该Class。

然后，它将再次使用反射为＜property＞元素获取适当的setter，并将其值设置为指定值。

Junit特别使用Reflection来测试Private/Protected方法。

对于私有方法，

Method method = targetClass.getDeclaredMethod(methodName, argClasses);
method.setAccessible(true);
return method.invoke(targetObject, argObjects);

对于私人领域，

Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);

反射允许在运行时动态实例化新对象、调用方法和获取/设置类变量的操作，而无需事先了解其实现。

Class myObjectClass = MyObject.class;
Method[] method = myObjectClass.getMethods();

//Here the method takes a string parameter if there is no param, put null.
Method method = aClass.getMethod("method_name", String.class); 

Object returnValue = method.invoke(null, "parameter-value1");

在上面的示例中，null参数是要对其调用方法的对象。如果方法是静态的，则提供null。如果该方法不是静态的，那么在调用时需要提供有效的MyObject实例而不是null。

反射还允许您访问类的私有成员/方法：

public class A{

  private String str= null;

  public A(String str) {
  this.str= str;
  }
}

.

A obj= new A("Some value");

Field privateStringField = A.class.getDeclaredField("privateString");

//Turn off access check for this field
privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(obj);
System.out.println("fieldValue = " + fieldValue);

为了检查类（也称为内省），不需要导入反射包（java.lang.reflect）。可以通过java.lang.Class访问类元数据。

反射是一个非常强大的API，但如果过度使用，它可能会降低应用程序的速度，因为它在运行时解析所有类型。

反射有很多用途。我更熟悉的是能够动态创建代码。

IE：基于任何数据的动态类、函数、构造函数（xml/array/sql results/hardcoded/etc.）

正如名称本身所暗示的，它除了提供在运行时动态调用创建实例的方法的功能之外，还反映了它所持有的例如类方法等。

许多框架和应用程序都使用它来调用服务，而实际上并不知道代码。