• 1 反射
  • 1.1 反射概述
  • 1.2 获取class对象三种方式
  • 1.3 反射实例分析
    • 1.3.1 获取反射方法
    • 1.3.2 获取class对象方式应用
    • 1.3.3 反射一个类的属性值
    • 1.3.4 反射创建类对象
    • 1.3.5 反射操作数组
  • 1.4 newInstance()和new()区别

1 反射

1.1 反射概述

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种 动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。当然反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解

Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理

1.2 获取class对象三种方式

Java运行的时候，某个类无论生成多少个对象，他们都会对应同一个Class对象，它表示正在运行程序中的类和接口。如何取得操作类的Class对象，常用的有三种方式：

• 调用Class的静态方法forName，如Class.forName("java.lang.String")；
• 使用类的.class语法，如：Class<?> cls = String.class；
• 调用对象的getClass方法，如：String str = "abc"；Class<?> cls = str .getClass()；

1.3 反射实例分析

1.3.1 获取反射方法

首先看一个简单的例子，通过这个例子来理解Java的反射机制是如何工作的。

package com.wanggc.reflection;

import java.lang.reflect.Method;

/**
 * Java 反射练习。
 * 
 * @author Wanggc
 */
public class ForNameTest {

    /**
     * 入口函数。
     * 
     * @param args
     *            参数
     * @throws Exception
     *             错误信息
     */
    public static void main(String[] args) throws Exception {
        // 获得Class
        Class<?> cls = Class.forName(args[0]);
        // 通过Class获得所对应对象的方法
        Method[] methods = cls.getMethods();
        // 输出每个方法名
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

当传入的参数是java.lang.String时，会输出如下结果

public boolean java.lang.String.equals(java.lang.Object)
public java.lang.String java.lang.String.toString()
public int java.lang.String.hashCode()
public int java.lang.String.compareTo(java.lang.String)
public int java.lang.String.compareTo(java.lang.Object)
public int java.lang.String.indexOf(int)
public int java.lang.String.indexOf(int,int)
public int java.lang.String.indexOf(java.lang.String)
public int java.lang.String.indexOf(java.lang.String,int)
public static java.lang.String java.lang.String.valueOf(int)
public static java.lang.String java.lang.String.valueOf(char)
public static java.lang.String java.lang.String.valueOf(boolean)
public static java.lang.String java.lang.String.valueOf(float)
public static java.lang.String java.lang.String.valueOf(char[],int,int)
public static java.lang.String java.lang.String.valueOf(double)
public static java.lang.String java.lang.String.valueOf(char[])
public static java.lang.String java.lang.String.valueOf(java.lang.Object)
public static java.lang.String java.lang.String.valueOf(long)
public char java.lang.String.charAt(int)
public int java.lang.String.codePointAt(int)
public int java.lang.String.codePointBefore(int)
public int java.lang.String.codePointCount(int,int)
public int java.lang.String.compareToIgnoreCase(java.lang.String)
public java.lang.String java.lang.String.concat(java.lang.String)
public boolean java.lang.String.contains(java.lang.CharSequence)
public boolean java.lang.String.contentEquals(java.lang.CharSequence)
public boolean java.lang.String.contentEquals(java.lang.StringBuffer)
public static java.lang.String java.lang.String.copyValueOf(char[])
public static java.lang.String java.lang.String.copyValueOf(char[],int,int)
public boolean java.lang.String.endsWith(java.lang.String)
public boolean java.lang.String.equalsIgnoreCase(java.lang.String)
public static java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[])
public static java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[])
public byte[] java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException
public void java.lang.String.getBytes(int,int,byte[],int)
public byte[] java.lang.String.getBytes()
public byte[] java.lang.String.getBytes(java.nio.charset.Charset)
public void java.lang.String.getChars(int,int,char[],int)
public native java.lang.String java.lang.String.intern()
public boolean java.lang.String.isEmpty()
public int java.lang.String.lastIndexOf(java.lang.String)
public int java.lang.String.lastIndexOf(int,int)
public int java.lang.String.lastIndexOf(int)
public int java.lang.String.lastIndexOf(java.lang.String,int)
public int java.lang.String.length()
public boolean java.lang.String.matches(java.lang.String)
public int java.lang.String.offsetByCodePoints(int,int)
public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int)
public boolean java.lang.String.regionMatches(int,java.lang.String,int,int)
public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence)
public java.lang.String java.lang.String.replace(char,char)
public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String)
public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String)
public java.lang.String[] java.lang.String.split(java.lang.String)
public java.lang.String[] java.lang.String.split(java.lang.String,int)
public boolean java.lang.String.startsWith(java.lang.String)
public boolean java.lang.String.startsWith(java.lang.String,int)
public java.lang.CharSequence java.lang.String.subSequence(int,int)
public java.lang.String java.lang.String.substring(int)
public java.lang.String java.lang.String.substring(int,int)
public char[] java.lang.String.toCharArray()
public java.lang.String java.lang.String.toLowerCase()
public java.lang.String java.lang.String.toLowerCase(java.util.Locale)
public java.lang.String java.lang.String.toUpperCase()
public java.lang.String java.lang.String.toUpperCase(java.util.Locale)
public java.lang.String java.lang.String.trim()
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

这样就列出了java.lang.String类的所有方法名、及其限制符、返回类型及抛出的异常。这个程序使用Class类forName方法载入指定的类，然后调用getMethods方法返回指定类的方法列表。java.lang.reflect.Method用来表述某个类中的单一方法。

使用java的反射机制，一般需要遵循三步：

• 获得你想操作类的Class对象
• 通过第一步获得的Class对象去取得操作类的方法或是属性名
• 操作第二步取得的方法或是属性

在获得类的方法、属性、构造函数时，会有getXXX和getDeclaredXXX两种对应的方法。之间的区别在于前者返回的是访问权限为public的方法和属性，包括父类中的；但后者返回的是所有访问权限的方法和属性，不包括父类的

1.3.2 获取class对象方式应用

下面将通过实例讲述如何通过前面所诉的三步来执行某对象的某个方法：·

 package com.wanggc.reflection;
  
  import java.lang.reflect.Method;
  
  /**
   * Java 反射练习。
   * 
   * @author Wanggc
   */
 public class ReflectionTest {
     public static void main(String[] args) throws Exception {
         DisPlay disPlay = new DisPlay();
         // 获得Class
         Class<?> cls = disPlay.getClass();
         // 通过Class获得DisPlay类的show方法
         Method method = cls.getMethod("show", String.class);
         // 调用show方法
         method.invoke(disPlay, "Wanggc");
     }
 }
 
 class DisPlay {
     public void show(String name) {
         System.out.println("Hello :" + name);
     }
 }

前面说过，Java程序的每个类都会有个Class对象与之对应。Java反射的第一步就是获得这个Class对象。当然，每个类的方法也必有一个Method对象与之对应。要通过反射的方式调用这个方法，就要首先获得这个方法的Method对象，然后用Method对象反过来调用这个方法。注意getMethod方法的第一个参数是方法名，第二个是此方法的参数类型，如果是多个参数，接着添加参数就可以了，因为getMethod是可变参数方法。invoke方法，其实也就是执行show方法，注意invoke的第一个参数，是DisPlay类的一个对象，也就是调用DisPlay类哪个对象的show方法，第二个参数是给show方法传递的参数。类型和个数一定要与getMethod方法一直。

1.3.3 反射一个类的属性值

上例讲述了如何通过反射调用某个类的方法，下面将再通过一个实例讲述如何通过反射给某个类的属性赋值：

 package com.wanggc.reflection;
   
  import java.lang.reflect.Field;
   
   /**
    * Java 反射之属性练习
    */
  public class ReflectionTest {
   public static void main(String[] args) throws Exception {
         // 建立学生对象
          Student student = new Student();
          // 为学生对象赋值
          student.setStuName("Wanggc");
          student.setStuAge(24);
         // 建立拷贝目标对象
          Student destStudent = new Student();
          // 拷贝学生对象
         copyBean(student, destStudent);
         // 输出拷贝结果
         System.out.println(destStudent.getStuName() + ":"
                 + destStudent.getStuAge());
     }
 
      /**
     * 拷贝学生对象信息。
      * 
      * @param from
      *            拷贝源对象
      * @param dest
      *            拷贝目标对象
      * @throws Exception
      *             例外
 */
     private static void copyBean(Object from, Object dest) throws Exception {
         // 取得拷贝源对象的Class对象
          Class<?> fromClass = from.getClass();
          // 取得拷贝源对象的属性列表
          Field[] fromFields = fromClass.getDeclaredFields();
         // 取得拷贝目标对象的Class对象
         Class<?> destClass = dest.getClass();
         Field destField = null;
         for (Field fromField : fromFields) {
             // 取得拷贝源对象的属性名字
             String name = fromField.getName();
             // 取得拷贝目标对象的相同名称的属性
              destField = destClass.getDeclaredField(name);
            // 设置属性的可访问性
             fromField.setAccessible(true);
             destField.setAccessible(true);
            // 将拷贝源对象的属性的值赋给拷贝目标对象相应的属性
             destField.set(dest, fromField.get(from));
        }
     }
 }
 
 /**
 * 学生类。
  */
 class Student {
     /** 姓名 */
      private String stuName;
      /** 年龄 */
     private int stuAge;
 
    /**
      * 获取学生姓名。
      * 
      * @return 学生姓名
 */
     public String getStuName() {
         return stuName;
     }
 
     /**
      * 设置学生姓名
      * 
      * @param stuName
      *            学生姓名
 */
     public void setStuName(String stuName) {
          this.stuName = stuName;
     }
 
     /**
      * 获取学生年龄
      * 
      * @return 学生年龄
 */
     public int getStuAge() {
         return stuAge;
     }
 
     /**
      * 设置学生年龄
      * 
      * @param stuAge
      *            学生年龄
 */
     public void setStuAge(int stuAge) {
         this.stuAge = stuAge;
     }
}

Java的发射机制中类有Class对应，类的方法有Method对应，当然属性也有Field与之对应。代码中注释已经做了详细的注释，在此不再赘述。但要注意，Field提供了get和set方法获取和设置属性的值，但是由于属性是私有类型，所以需要设置属性的可访问性为true。也可以在为整个fields设置可访问性，使用AccessibleObject的静态方法setAccessible，如：AccessibleObject.setAccessible(fromFields, true);

1.3.4 反射创建类对象

前面讲述了如何用Java反射机制操作一个类的方法和属性，下面再通过一个实例讲述如何在运行时创建类的一个对象：

  package com.wanggc.reflection;
  
  import java.lang.reflect.Field;
  
  /**
   * Java 反射之属性练习。
   * 
   * @author Wanggc
   */
 public class ReflectionTest {
     public static void main(String[] args) throws Exception {
         // 建立学生对象
         Student student = new Student();
         // 为学生对象赋值
         student.setStuName("Wanggc");
         student.setStuAge(24);
         // 建立拷贝目标对象
         Student destStudent = (Student) copyBean(student);
         // 输出拷贝结果
         System.out.println(destStudent.getStuName() + ":"
                 + destStudent.getStuAge());
     }
 
     /**
      * 拷贝学生对象信息。
      * 
      * @param from
      *            拷贝源对象
      * @param dest
      *            拷贝目标对象
      * @throws Exception
      *             例外
*/
     private static Object copyBean(Object from) throws Exception {
         // 取得拷贝源对象的Class对象
         Class<?> fromClass = from.getClass();
         // 取得拷贝源对象的属性列表
         Field[] fromFields = fromClass.getDeclaredFields();
         // 取得拷贝目标对象的Class对象
         Object ints = fromClass.newInstance();
         for (Field fromField : fromFields) {
             // 设置属性的可访问性
             fromField.setAccessible(true);
             // 将拷贝源对象的属性的值赋给拷贝目标对象相应的属性
             fromField.set(ints, fromField.get(from));
         }
 
         return ints;
     }
}
 
 /**
  * 学生类。
  */
 class Student {
     /** 姓名 */
    private String stuName;
     /** 年龄 */
     private int stuAge;
 
     /**
      * 获取学生姓名。
      * 
      * @return 学生姓名
 */
     public String getStuName() {
        return stuName;
     }
 
     /**
      * 设置学生姓名
      * 
      * @param stuName
      *            学生姓名
 */
     public void setStuName(String stuName) {
         this.stuName = stuName;
     }
 
     /**
      * 获取学生年龄
      * 
      * @return 学生年龄
*/
     public int getStuAge() {
         return stuAge;
    }
 
     /**
      * 设置学生年龄
      * 
      * @param stuAge
      *            学生年龄
 */
     public void setStuAge(int stuAge) {
         this.stuAge = stuAge;
     }
}

此例和上例运行的结果是相同的。但是copyBean方法返回的对象不再是外面传入的，而是由方法内部产生的。注意：Class的newInstance方法，只能创建只包含无参数的构造函数的类，如果某类只有带参数的构造函数，那么就要使用另外一种方式

fromClass.getDeclaredConstructor(int.class,String.class)
.newInstance(24,"wanggc");

1.3.5 反射操作数组

反射中getComponentType()方法可以取得一个数组的Class对象

import java.lang.reflect.*;
class hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5};
        Class<?>demo=temp.getClass().getComponentType();
        System.out.println("数组类型： "+demo.getName());
        System.out.println("数组长度  "+Array.getLength(temp));
        System.out.println("数组的第一个元素: "+Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之后数组第一个元素为： "+Array.get(temp, 0));
    }
}

1.4 newInstance()和new()区别

在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后，一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此，单单使用Class.forName( )是动态加载类是没有用的，其最终目的是为了实例化对象

那么Class下的newInstance()和new有什么区别？
首先，newInstance( )是一个方法，而new是一个关键字，其次，Class下的newInstance()的使用有局限，因为它生成对象只能调用无参的构造函数，而使用new关键字生成对象没有这个限制。
即：Class.forName("")返回的是类，Class.forName("").newInstance()返回的是object

有数据库开发经验朋友会发现，为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢？有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一些Class.forName(xxx.xx.xx).newInstance()，为什么会有这两种写法呢？
Class.forName("");的作用是要求JVM查找并加载指定的类，如果在类中有静态初始化器的话，JVM必然会执行该类的静态代码段。而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己，即任何一个JDBC Driver的Driver类的代码都必须类似如下：

public class MyJDBCDriver implements Driver {
static {
DriverManager.registerDriver(new MyJDBCDriver());
}
}

既然在静态初始化器的中已经进行了注册，所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了

Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：

class c = Class.forName(“Example”);
factory = (ExampleInterface)c.newInstance();

其中ExampleInterface是Example的接口，可以写成如下形式：
String className = "Example";
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();

进一步可以写成如下形式：
String className = readfromXMlConfig;//从xml 配置文件中获得字符串
class c = Class.forName(className);
factory = (ExampleInterface)c.newInstance();

上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。
从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：

• 这个 类已经加载；
• 这个类已经连接了。

而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载 java API的那个加载器。
现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。
最后用最简单的描述来区分new关键字和newInstance()方法的区别：

• newInstance: 弱类型。低效率。只能调用无参构造。
• new: 强类型。相对高效。能调用任何public构造