Java 反射教程

这是我的第一篇博客，以此纪念下。

最近在重新梳理Java的基础知识，这篇文章记一下Java的反射机制

 

1.什么是反射

　　“反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省（Introspection）混淆，以下是这两个术语在Wikipedia中的解释：

1. 1. 内省用于在运行时检测某个对象的类型和其包含的属性；　　
   2. 反射用于在运行时检测和修改某个对象的结构及其行为。

　

　　内省示例：instanceof 运算符用于检测某个对象是否属于特定的类。

if (obj instanceof Dog) {
    Dog d = (Dog) obj;
    d.bark();
}

 

　　反射示例：Class.forName()方法可以通过类或接口的名称（一个字符串或完全限定名）来获取对应的Class对象。forName方法会触发类的初始化。

// 使用反射
Class<?> c = Class.forName("classpath.and.classname");
Object dog = c.newInstance();
Method m = c.getDeclaredMethod("bark", new Class<?>[0]);
m.invoke(dog);

　　在Java中，反射更接近于内省，因为你无法改变一个对象的结构。虽然一些API可以用来修改方法和属性的可见性，但并不能修改结构。

2.为何需要反射?

　　反射能够让我们：

• 在运行时检测对象的类型；
• 动态构造某个类的对象；
• 检测类的属性和方法；
• 任意调用对象的方法；
• 修改构造函数、方法、属性的可见性；
• 以及其他。

　　反射也是框架中常用的方法。

 

　　例如，JUnit通过反射来遍历包含 @Test 注解的方法，并在运行单元测试时调用它们。

　　对于Web框架，开发人员在配置文件中定义他们对各种接口和类的实现。通过反射机制，框架能够快速地动态初始化所需要的类。

　　例如，Spring框架使用如下的配置文件：

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

　　当Spring容器处理<bean>元素时，会使用Class.forName("com.programcreek.Foo")来初始化这个类，并再次使用反射获取<property>元素对应的setter方法，为对象的属性赋值。

　　Servlet也会使用相同的机制：

<servlet>
    <servlet-name>someServlet</servlet-name>
    <servlet-class>com.programcreek.WhyReflectionServlet</servlet-class>
<servlet>

3.如何使用反射？

　　示例1：获取对象的类型名称。

　　

package myreflection;
import java.lang.reflect.Method;
 
public class ReflectionHelloWorld {
    public static void main(String[] args){
        Foo f = new Foo();
        System.out.println(f.getClass().getName());         
    }
}
 
class Foo {
    public void print() {
        System.out.println("abc");
    }
}

　　输出： myreflection.Foo

　　

　　示例2：调用未知对象的方法

　　在下列代码中，设想对象的类型是未知的。通过反射，我们可以判断它是否包含print方法，并调用它。

　　

package myreflection;
import java.lang.reflect.Method;
 
public class ReflectionHelloWorld {
    public static void main(String[] args){
        Foo f = new Foo();
 
        Method method;
        try {
            method = f.getClass().getMethod("print", new Class<?>[0]);
            method.invoke(f);
        } catch (Exception e) {
            e.printStackTrace();
        }           
    }
}
 
class Foo {
    public void print() {
        System.out.println("abc");
    }
}
//输出 : abc

 

　　示例3：创建对象

　　

package myreflection;
 
public class ReflectionHelloWorld {
    public static void main(String[] args){
        // 创建Class实例
        Class<?> c = null;
        try{
            c=Class.forName("myreflection.Foo");
        }catch(Exception e){
            e.printStackTrace();
        }
 
        // 创建Foo实例
        Foo f = null;
 
        try {
            f = (Foo) c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }   
 
        f.print();
    }
}
 
class Foo {
    public void print() {
        System.out.println("abc");
    }
}

 

　　示例4：获取构造函数，并创建对象。

package myreflection;
 
import java.lang.reflect.Constructor;
 
public class ReflectionHelloWorld {
    public static void main(String[] args){
        // 创建Class实例
        Class<?> c = null;
        try{
            c=Class.forName("myreflection.Foo");
        }catch(Exception e){
            e.printStackTrace();
        }
 
        // 创建Foo实例
        Foo f1 = null;
        Foo f2 = null;
 
        // 获取所有的构造函数
        Constructor<?> cons[] = c.getConstructors();
 
        try {
            f1 = (Foo) cons[0].newInstance();
            f2 = (Foo) cons[1].newInstance("abc");
        } catch (Exception e) {
            e.printStackTrace();
        }   
 
        f1.print();
        f2.print();
    }
}
 
class Foo {
    String s; 
 
    public Foo(){}
 
    public Foo(String s){
        this.s=s;
    }
 
    public void print() {
        System.out.println(s);
    }
}

//输出：
// null
// abc

 

　　此外，还可以通过Class实例来获取该类实现的接口、父类、声明的属性等

 

　　示例5：通过反射来修改数组的大小

package myreflection;
 
import java.lang.reflect.Array;
 
public class ReflectionHelloWorld {
    public static void main(String[] args) {
        int[] intArray = { 1, 2, 3, 4, 5 };
        int[] newIntArray = (int[]) changeArraySize(intArray, 10);
        print(newIntArray);
 
        String[] atr = { "a", "b", "c", "d", "e" };
        String[] str1 = (String[]) changeArraySize(atr, 10);
        print(str1);
    }
 
    // 修改数组的大小
    public static Object changeArraySize(Object obj, int len) {
        Class<?> arr = obj.getClass().getComponentType();
        Object newArray = Array.newInstance(arr, len);
 
        // 复制数组
        int co = Array.getLength(obj);
        System.arraycopy(obj, 0, newArray, 0, co);
        return newArray;
    }
 
    // 打印
    public static void print(Object obj) {
        Class<?> c = obj.getClass();
        if (!c.isArray()) {
            return;
        }
 
        System.out.println("\nArray length: " + Array.getLength(obj));
 
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i) + " ");
        }
    }
}

　　输出：

Array length: 10
1 2 3 4 5 0 0 0 0 0 
Array length: 10
a b c d e null null null null null

总结

　　上述示例仅仅是展示了Java反射机制很小的一部分功能。总之，反射机制是框架技术的原理和核心部分。通过反射机制我们可以动态的通过改变配置文件(以后是XML文件)的方式来加载类、调用类方法，以及使用类属性。这样的话，对于编码和维护带来相当大的便利。在程序进行改动的时候，也只会改动相应的功能就行了，调用的方法是不用改的。更不会一改就改全身。

 

转载于:https://www.cnblogs.com/jhoo/p/7922584.html