java反射机制（一）

/**
*@ author StormMaybin
*@ date 2016-09-26
*/

生命不息，奋斗不止！

---

反射基本概念

Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。
Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。
换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

反射API

Member接口	该接口可以获取有关类成员（域或者方法）后者构造函数的信息。
AccessibleObject类	该类是域(field)对象、方法(method)对象、构造函数(constructor)对象的基础类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。
Array类	该类提供动态地生成和访问JAVA数组的方法。
Constructor类	提供一个类的构造函数的信息以及访问类的构造函数的接口。
Field类	提供一个类的域的信息以及访问类的域的接口。
Method类	提供一个类的方法的信息以及访问类的方法的接口。
Modifier类	提供了 static 方法和常量，对类和成员访问修饰符进行解码。
Proxy类	提供动态地生成代理类和类实例的静态方法。

获取Class 对象

package com.stormma.reflect;

public class ClassDemo1
{

    public static void main(String[] args)
    {
        //Fu的实例对象
        Fu fu = new Fu();
        //Fu这个类也是一个实例化对象
        Class<Fu> c1 = Fu.class;
        Class<? extends Fu> c2 = fu.getClass();
        Class c3 = null;
        try
        {
            c3 = Class.forName("com.stormma.reflect.Fu");
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        System.out.println(c1 == c2 && c1 == c2);
        /**
         * 可以通过类类型的实例化对象创建该类的实例化对象
         */
        try
        {
            Fu fu1 = (Fu) c2.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}
class Fu 
{
    public void print ()
    {
        System.out.println("---");
    }
}

小例子

动态加载类

package com.stormma.reflect;

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * 
 * @author StormMaybin
 */
public class ClassDemo2
{
    private static Scanner scan = null;
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        String string = null;
        scan = new Scanner(new BufferedInputStream(System.in));
        while (scan.hasNext())
        {
            string = scan.next();
            if (!string.equals("Demo1") && !string.equals("Demo2"))
                System.out.println("Illegal Input");
            else
            {
                try
                {
                    //得到类类型
                    Class c = Class.forName("com.stormma.reflect."+string);
                    DemoAble demo = (DemoAble) c.newInstance();
                    demo.start();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        }
    }

}
class Demo1 implements DemoAble
{

    @Override
    public void start()
    {
        // TODO Auto-generated method stub
        System.out.println("Demo1 Start");
    }
}
class Demo2 implements DemoAble
{

    @Override
    public void start()
    {
        // TODO Auto-generated method stub
        System.out.println("Demo Start");
    }
}
//标准
interface DemoAble 
{
    public void start();
}

获取类的方法、构造方法以及属性

package com.stormma.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ClassDemo3
{

    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
//      ClassUtil.getClassMethods("");
//      ClassUtil.getClassConstructor("");
//      ClassUtil.getClassFields(1);
    }
}
class ClassUtil
{
    public static void getClassMethods (Object object)
    {
        //得到类类型实例化对象
        Class c = object.getClass();
        Method [] method = c.getDeclaredMethods();
        for (Method m : method)
        {
            System.out.print(Modifier.toString(m.getModifiers())+" "+m.getReturnType().getName()+" "+m.getName() + "( " );
            Class [] classType = m.getParameterTypes();
            for (int i = 0; i < classType.length; i++)
            {
                if (i < classType.length-1)
                    System.out.print(classType[i].getName() + ", ");
                else
                    System.out.print(classType[i].getName() + "");
            }
            System.out.println(")");
        }
    }
    public static void getClassConstructor(Object object)
    {
        Class c = object.getClass();
        Constructor [] conMethod = c.getDeclaredConstructors();
        for (Constructor conm : conMethod)
        {
            System.out.print(Modifier.toString(conm.getModifiers())+" "+" "+conm.getName() + "( " );
            Class [] classType = conm.getParameterTypes();
            for (int i = 0; i < classType.length; i++)
            {
                if (i < classType.length-1)
                    System.out.print(classType[i].getName() + ", ");
                else
                    System.out.print(classType[i].getName() + "");
            }
            System.out.println(")");
        }
    }
    public static void getClassFields (Object object)
    {
        Class c = object.getClass();
        Field [] field = c.getFields();
        for (Field f : field)
        {
            System.out.println(Modifier.toString(f.getModifiers())+" "+f.getName());
        }
    }
}

完。