Java中的反射（一）

1. Java提供的反射机制允许您在运行时动态加载类、查看类信息、生成对象或操作生成的对象。反射机制的一个应用实例，就是在整合式开发环境中所提供的方法提示或是类查看工具。另外像JSP中的JavaBean自动收集请求信息也使用到反射，而一些软件开发框架也常见到反射机制的使用，以达到动态加载使用者自定义类的目的。

2. 简介Class与类加载：

    Java在真正需要使用一个类时才会加以加载。一个java.lang.Class对象代表了Java应用程序在运行时所加载的类或接口实例，也用来表达enum(属于类的一种)、annotation(属于接口的一种)、数组、初始类型、void。Class类没有公开的构造函数。Class对象由JVM自动产生，每当一个类被加载时，JVM就自动为其生成一个Class对象。

3. 可以通过Object的getClass()方法来取得每个对象对应的Class对象，或者是通过class常量，在取得Class对象之后，就可以操作Class对象上的一些公开方法来取得类的基本信息。

package onlyfun.caterpillar;
 
public class ClassDemo {
    public static void main(String[] args) {
        String name = "caterpillar";
        Class stringClass = name.getClass();
        System.out.println("类名称：" + 
                    stringClass.getName()); 
        System.out.println("是否为接口：" + 
                    stringClass.isInterface()); 
        System.out.println("是否为基本类型：" + 
                    stringClass.isPrimitive()); 
        System.out.println("是否为数组对象：" + 
                    stringClass.isArray()); 
        System.out.println("父类名称：" + 
                    stringClass.getSuperclass().getName());
    }
} 

 也可以直接使用以下的方式来取得String类的Class对象：   

Class stringClass = String.class;

  Java在真正需要类时才会加载类，所谓真正需要通常指的是要使用指定的类生成对象时（或是使用者指定要加载类时，例如使用Class.forName()加载类，或是使用ClassLoader的loadClass()加载类）。使用类名称来声明参考名称并不会类的加载。下面是印证这个说法的一个测试类。

 

package ysu.hxy;

public class TestClass {
    static {
        System.out.println("类被载入");
    }
}

 

上此范例中定义了一个静态区块，默认在类第一次被加载时会运行静态区块，通过运行在命令模式下的显示信息，可以了解类何时被加载：

package ysu.hxy;

public class LoadClassTest {
    public static void main(String[] args) {
        TestClass test = null;
        System.out.println("声明TestClass参考名称");
        test = new TestClass();
        System.out.println("生成TestClass实例");
    }
}

 运行结果如下：

  D:\hxy>java ysu.hxy.LoadClassTest
  声明TestClass参考名称
  类被载入
  生成TestClass实例

  从运行结果可以看出，声明参考名称并不导致TestClass类被加载，而是在使用new生成对象时才会加载类。

4. Class的信息是在编译时期就被加入至.class文件中，这是Java支持运行时期类型辨识(Run-Time Type Information或Run-Time Type Identification,RTTI)的一种方式：在编译时期编译器会先检查对应的.class文件，而运行时期JVM在使用某类时，会先检查对应的Class对象是否已经加载，如果没有加载，则会寻找对应的.class文件并载入。一个类在JVM中只会有一个Class实例，每个类的实例都会记得自己是由哪个Class实例所生成，可以使用getClass()或.class来取得Class实例。

5. 在Java中，数组也是一个对象，也有其对应的Class实例。这个对象由具有相同元素与维度的数组所共享，而基本类型和关键词void，也都有对应的Class对象。可以用类常量来取得这些对象。

package ysu.hxy;

public class ClassDemo2
{
	public static void main(String[] args) 
	{
		System.out.println(boolean.class);
		System.out.println(void.class);

		int[] iarr = new int[10];
		System.out.println(iarr.getClass().toString());
		double[] darr = new double[10];
		System.out.println(darr.getClass().toString());
	}
}

6. 使用Class.forName()加载类：

    Class的静态forName()方法可以实现动态加载类的目的。如下例：

 

package ysu.hxy;
 
public class ForNameDemo {
    public static void main(String[] args) { 
        try {
            Class c = Class.forName(args[0]);
            System.out.println("类名称：" + 
                          c.getName()); 
            System.out.println("是否为接口：" + 
                             c.isInterface()); 
            System.out.println("是否为基本类型：" + 
                             c.isPrimitive()); 
            System.out.println("是否为数组：" + c.isArray()); 
            System.out.println("父类：" + 
                             c.getSuperclass().getName());
        }
        catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("没有指定类名称");
        }
        catch(ClassNotFoundException e) {
            System.out.println("找不到指定的类");
        }
    }
} 

一个运行的结果如下：

D:\hxy>java ysu.hxy.ForNameDemo java.util.Scanner
类名称：java.util.Scanner
是否为接口：false
是否为基本类型：false
是否为数组：false
父类：java.lang.Object
  Class的静态forName()方法有两个版本，上面使用的是只指定类名称的版本，而另一个版本可以让您指定类名称、加载类时是否运行静态区块、指定类加载器：

static Class forName(String name,boolean initialize,ClassLoader loader)

 默认在加载类的时候，如果类中有定义静态区块则会运行它。你可以使用forName()的第二个版本，将initialize设定为false，这样在加载类时并不会立即运行静态区块，而会在使用类建立对象时才运行静态区块。以下是一个测试类：

package ysu.hxy;

public class TestClass2 {
    static {
        System.out.println("[运行静态区块]");
    }
}

 

使用第一个版本forName()方法的测试代码：

package ysu.hxy;
 
public class ForNameDemoV1 {
    public static void main(String[] args) { 
        try {
            System.out.println("载入TestClass2");
            Class c = Class.forName("ysu.hxy.TestClass2");

            System.out.println("使用TestClass2声明参考名称");
            TestClass2 test = null;

            System.out.println("使用TestClass2建立对象");                        
            test = new TestClass2();
        }
        catch(ClassNotFoundException e) {
            System.out.println("找不到指定的类");
        }
    }
}

 运行结果如下：

D:\hxy>java ysu.hxy.ForNameDemoV1
载入TestClass2
[运行静态区块]
使用TestClass2声明参考名称
使用TestClass2建立对象

使用第二个版本的forName()代码：

package ysu.hxy;
 
public class ForNameDemoV2 {
    public static void main(String[] args) { 
        try {
            System.out.println("载入TestClass2");
            Class c = Class.forName(
                         "ysu.hxy.TestClass2", 
                         false, // 加载类时不运行静态区块, 在使用类建立对象时才运行静态区块，此版本的forName()需要一个类加载器，这里使用的是主线程的类加载器
                         Thread.currentThread().getContextClassLoader());

            System.out.println("使用TestClass2声明参考名称");
            TestClass2 test = null;

            System.out.println("使用TestClass2建立对象");                        
            test = new TestClass2();
        }
        catch(ClassNotFoundException e) {
            System.out.println("找不到指定的类");
        }
    }
}

运行结果如下：

D:\hxy>java ysu.hxy.ForNameDemoV2
载入TestClass2
使用TestClass2声明参考名称使用TestClass2建立对象
[运行静态区块]

7. 从Class中获取信息：Class对象表示所加载的类，取得Class对象之后，就可以取得与类相关联的信息，像包、构造函数、方法成员、域成员等的信息，而每个信息，也会有相应的类类型。如包的对应类型是java.lang.Package；构造函数的对应类型是java.lang.reflect.Constructor；方法成员的对应类型是java.lang.reflect.Method；域成员的对应类型是java.lang.reflect.Field等。可以取回Field、Constructor、Method等对象，它们分别代表域成员、构造函数与方法成员。下面是个范例：

package ysu.hxy;

import java.lang.reflect.*;

public class SimpleClassViewer
{
	public static void main(String[] args) 
	{
	    try
		{
            Class c = Class.forName(args[0]);
			//取得包代表对象
			Package p = c.getPackage();
			
			System.out.printf("package %s;%n",p.getName());

			//取得类型修饰,像class,interface
			int m = c.getModifiers();

			System.out.print(Modifier.toString(m) + " ");
			if(Modifier.isInterface(m)){
				System.out.print("interface ");
			}
			else
			{
				System.out.print("class ");
			}

			System.out.println(c.getName() + " {");

			//取得声明的域成员对象 
			Field[] fields = c.getDeclaredFields();
			for(Field field: fields)
			{
				//显示权限修饰，像public、protected、private
				System.out.print("\t"+Modifier.toString(field.getModifiers()));

				//显示类型名称
				System.out.print(" " + field.getType().getName() + " ");

				//显示域成员名称
				System.out.println(field.getName()+";");
			}

			//取得声明的构造函数代表对象
			Constructor[] constructors= c.getDeclaredConstructors();
		    for(Constructor constructor: constructors)
		    {
				//显示权限修饰，像public,private,protected
				System.out.print("\t"+Modifier.toString(constructor.getModifiers()));

				//显示构造函数名称
				System.out.println(" " +constructor.getName()+"();");
			}

			//取得声明的方法成员代表对象
			Method[] methods = c.getDeclaredMethods();
			for(Method method:methods)
			{
				//显示权限修饰
                System.out.print("\t"+Modifier.toString(method.getModifiers()));

				//显示返回类型
				System.out.print(" "+method.getReturnType().getName()+ " ");

				//显示方法名称
				System.out.println(" " + method.getName()+"();");
			}
			System.out.println("}");
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("没有指定类");
		}
		catch(ClassNotFoundException e)
		{
			System.out.println("找不到指定类");
		}
	}
}

运行结果：

D:\hxy>java ysu.hxy.SimpleClassViewer java.util.ArrayList
package java.util;
public class java.util.ArrayList {
        private static final long serialVersionUID;
        private transient [Ljava.lang.Object; elementData;
        private int size;
        public java.util.ArrayList();
        public java.util.ArrayList();
        public java.util.ArrayList();
        public boolean  add();
        public void  add();
        public java.lang.Object  get();
        public java.lang.Object  clone();
        public int  indexOf();
        public void  clear();
        public boolean  contains();
        public boolean  isEmpty();
        public int  lastIndexOf();
        public boolean  addAll();
        public boolean  addAll();
        public int  size();
        public [Ljava.lang.Object;  toArray();
        public [Ljava.lang.Object;  toArray();
        public boolean  remove();
        public java.lang.Object  remove();
        private void  writeObject();
        private void  readObject();
        public java.lang.Object  set();
        public void  ensureCapacity();
        protected void  removeRange();
        public void  trimToSize();
        private void  RangeCheck();
        private void  fastRemove();
}