重要的

从Java9开始，您不能再使用反射，除非package-info.Java打开模块以进行反射访问。

默认情况下，拒绝对模块中的所有包进行“反射”访问。

请参阅了解Java 9模块

名称反射用于描述能够检查同一系统（或其本身）中其他代码的代码。

例如，假设您在Java中有一个未知类型的对象，如果存在，您希望对其调用“doSomething”方法。Java的静态类型系统并不是为了支持这一点而设计的，除非对象符合已知的接口，但是使用反射，您的代码可以查看对象并找出它是否有一个名为“doSomething”的方法，如果需要，可以调用它。

因此，给您一个Java代码示例（假设所讨论的对象是foo）：

Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);

Java中一个非常常见的用例是注释的用法。例如，JUnit4将使用反射在类中查找标记有@Test注释的方法，然后在运行单元测试时调用它们。

有一些很好的反思示例可以帮助您开始http://docs.oracle.com/javase/tutorial/reflect/index.html

最后，是的，这些概念在其他支持反射的静态类型语言（如C#）中非常相似。在动态类型语言中，上面描述的用例不太必要（因为编译器将允许在任何对象上调用任何方法，如果不存在，则在运行时失败），但是第二种情况仍然很常见，即查找被标记或以某种方式工作的方法。

从评论更新：

检查系统中的代码并查看对象类型的能力是不是反思，而是类型反思。反射就是能够在运行时通过使用反省在某些语言中，这种区别是必要的支持内省，但不支持反思。一个这样的例子是C++

我想举个例子来回答这个问题。首先，Hibernate项目使用反射API生成CRUD语句，以弥合运行应用程序和持久性存储之间的鸿沟。当域中的情况发生变化时，Hibernate必须了解这些情况，才能将其持久化到数据存储中，反之亦然。

另外，Lombok项目也可以。它只是在编译时注入代码，导致代码被插入到域类中。（我认为这对getter和setter来说是可以的）

Hibernate选择反射是因为它对应用程序的构建过程影响最小。

在Java7中，我们有MethodHandles，它用作反射API。在项目中，要使用记录器，我们只需复制粘贴下一个代码：

Logger LOGGER = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());

因为在这种情况下很难出错。

重要的

从Java9开始，您不能再使用反射，除非package-info.Java打开模块以进行反射访问。

默认情况下，拒绝对模块中的所有包进行“反射”访问。

请参阅了解Java 9模块

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

使用反射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;
   }    
}

根据我的理解：

反射允许程序员动态访问程序中的实体。也就是说，当程序员对应用程序进行编码时，如果不知道类或其方法，他可以通过使用反射来动态地（在运行时）使用此类类。

它经常用于类名频繁更改的场景。如果出现这种情况，那么程序员重写应用程序并一次又一次地更改类的名称是很复杂的。

相反，通过使用反射，需要担心类名可能会发生变化。