JAVA反射学习

1.Class类

package com.hxy;

class Foo{}

public class Reflect 
{
    public static void main(String[] args) 
    {
        //1.获取Class对象
        Class c1 = Foo.class;
        
        Class c2 = new Foo().getClass();
        
        Class c3 = null;
        try 
        {
            c3 = Class.forName("com.hxy.Foo");
        } 
        catch (ClassNotFoundException e) 
        {
            e.printStackTrace();
        }
        
        System.out.println(c1 == c2);
        System.out.println(c2 == c3);    
        //true
        //true
        
        //2.通过类的Class对象创建该类实例
        try 
        {
            //调用newInstance方法需要Foo类有无参数的构造方法
            Foo foo1 = (Foo) c1.newInstance();
        } 
        catch (InstantiationException e) 
        {
            e.printStackTrace();
        } catch (IllegalAccessException e) 
        {
            e.printStackTrace();
        }
        
        //3.动态加载类
        
        //编译时刻加载类是“静态加载类”
        //运行时刻加载类是“动态加载类”
        
        //new创建对象是“静态加载类”，编译时刻就需要加载所有可能使用的类，无论是否可能用到    
        
        //Class.forName("完整类名")是动态加载类，要动态加载的类会在运行时加载
        //好处：动态加载的类可以随意添加或者更改，而不需要编译此文件
        
        //基本数据类型也有对应的Class
        Class c4 = int.class;
        Class c5 = Integer.class;
        System.out.println(c4 == c5);
        //false
        
        //注：基本的数据类型和void都存在相应的Class对象
        Class c6 = void.class;
        
        //getName()获取类全称
        //getSimpleName获取不包含包名的类的名称
        System.out.println(c4.getName());
        System.out.println(c5.getName());
        System.out.println(c6.getName());
        //int
        //java.lang.Integer
        //void
    }
}

2.获取类的成员变量、方法以及构造函数信息

ClassUtil.java:

package com.hxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassUtil 
{
    public static void printFieldMessage(Object obj)
    {
        Class c = obj.getClass();
        System.out.println("类的名称是：" + c.getName());
        System.out.println("获取成员变量列表：");
        //getFields()方法获取的是所有public的成员变量，包括继承而来的
        //getDeclaredFields()方法获取的是所有该类自己声明的成员变量，不论访问权限
        Field[] fields = c.getDeclaredFields();
        for(int i = 0; i < fields.length; i++)
        {
            Class fieldType = fields[i].getType();
            String typeName = fieldType.getName();
            String fieldName = fields[i].getName();
            System.out.println(typeName + " " + fieldName);
        }
        System.out.println("获取成员变量列表结束。");
    }
    
    public static void printMethodMessage(Object obj)
    {
        Class c = obj.getClass();
        System.out.println("类的名称是：" + c.getName());
        //getMethods()方法获取的是所有public的函数，包括继承而来的
        //getDeclaredMethods()方法获取的是所有该类自己声明的方法，不论访问权限
        Method[] methods = c.getMethods();
        System.out.println("获取方法列表：");
        for(Method m: methods)
        {
            Class returnType = m.getReturnType();
            System.out.print(returnType.getName() + " " + m.getName() + "(");
            Class[] paramTypes = m.getParameterTypes();
            for(int i = 0; i < paramTypes.length; i++)
            {
                String info = paramTypes[i].getName();
                if(i != paramTypes.length - 1)
                {
                    info = info + ", ";
                }
                System.out.print(info);
            }
            System.out.println(")");
        }
        System.out.println("获取方法列表结束。");
    }

    public static void printConstructorMessage(Object obj)
    {
        Class c = obj.getClass();
        System.out.println("类的名称是：" + c.getName());
        System.out.println("获取构造函数列表：");
        Constructor[] constructors = c.getDeclaredConstructors();
        for(Constructor constructor: constructors)
        {
            System.out.print(constructor.getName() + "(");
            Class[] paramTypes = constructor.getParameterTypes();
            for(int i = 0; i < paramTypes.length; i++)
            {
                String info = paramTypes[i].getName();
                if(i != paramTypes.length - 1)
                {
                    info = info + ", ";
                }
                System.out.print(info);
            }
            System.out.println(")");
        }
        System.out.println("获取构造函数列表结束。");
    }
}

ClassUtilTest.java:

package com.hxy;

public class ClassUtilTest 
{
    public static void main(String[] args)
    {
        Integer integer = 6;
        ClassUtil.printMethodMessage(integer);
        System.out.println("<------------------->");
        ClassUtil.printFieldMessage(integer);
        System.out.println("<------------------->");
        ClassUtil.printConstructorMessage(integer);
    }
}

运行结果：

类的名称是：java.lang.Integer
获取方法列表：
int numberOfLeadingZeros(int)
int numberOfTrailingZeros(int)
int bitCount(int)
boolean equals(java.lang.Object)
java.lang.String toString(int, int)
java.lang.String toString()
java.lang.String toString(int)
int hashCode(int)
int hashCode()
int min(int, int)
int max(int, int)
int reverseBytes(int)
int compareTo(java.lang.Integer)
int compareTo(java.lang.Object)
byte byteValue()
short shortValue()
int intValue()
long longValue()
float floatValue()
double doubleValue()
java.lang.Integer valueOf(java.lang.String, int)
java.lang.Integer valueOf(int)
java.lang.Integer valueOf(java.lang.String)
java.lang.String toHexString(int)
int compare(int, int)
java.lang.Integer decode(java.lang.String)
int reverse(int)
int sum(int, int)
int parseInt(java.lang.String)
int parseInt(java.lang.String, int)
long toUnsignedLong(int)
int compareUnsigned(int, int)
int divideUnsigned(int, int)
java.lang.Integer getInteger(java.lang.String, java.lang.Integer)
java.lang.Integer getInteger(java.lang.String, int)
java.lang.Integer getInteger(java.lang.String)
int highestOneBit(int)
int lowestOneBit(int)
int parseUnsignedInt(java.lang.String)
int parseUnsignedInt(java.lang.String, int)
int remainderUnsigned(int, int)
int rotateLeft(int, int)
int rotateRight(int, int)
int signum(int)
java.lang.String toBinaryString(int)
java.lang.String toOctalString(int)
java.lang.String toUnsignedString(int)
java.lang.String toUnsignedString(int, int)
void wait()
void wait(long, int)
void wait(long)
java.lang.Class getClass()
void notify()
void notifyAll()
获取方法列表结束。
<------------------->
类的名称是：java.lang.Integer
获取成员变量列表：
int MIN_VALUE
int MAX_VALUE
java.lang.Class TYPE
[C digits
[C DigitTens
[C DigitOnes
[I sizeTable
int value
int SIZE
int BYTES
long serialVersionUID
获取成员变量列表结束。
<------------------->
类的名称是：java.lang.Integer
获取构造函数列表：
java.lang.Integer(int)
java.lang.Integer(java.lang.String)
获取构造函数列表结束。

3.方法的反射

package com.hxy;
import java.lang.reflect.Method;

class A
{
    public void print(int a, int b)
    {
        System.out.println(a + b);
    }
}

public class MethodReflect 
{
    public static void main(String[] args)
    {
        A obj = new A();
        Class c = obj.getClass();
        try 
        {
            //正常方法调用
            obj.print(10, 20);
            
            //方法的反射
            Method m = c.getMethod("print", int.class, int.class);
            m.invoke(obj, 10, 20);
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        } 
    }
}

运行结果：

30
30

一个简单的例子体现方法反射的优越性：
UserService.java:

package com.hxy;

public class UserService 
{
    public void delete()
    {
        System.out.println("Delete Service Starts");
    }
    
    public void update()
    {
        System.out.println("Update Service Starts");
    }
    
    public void find()
    {
        System.out.println("Find Service Starts");
    }
}

UserServiceInterface.java:

package com.hxy;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Method;

public class UserServiceInterface 
{
    public static void main(String[] args) 
    {
        UserService us = new UserService();
        try 
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Please Input Your Operation: ");
            String action = br.readLine();
            /*
            常规写法（不符合开闭原则）
            if("update".equals(action))
            {
                us.update();
            }
            if("delete".equals(action))
            {
                us.delete();
            }
            if("find".equals(action))
            {
                us.find();
            }
            */
            //运用反射的优雅写法
            Class c = us.getClass();
            Method m = c.getMethod(action);
            m.invoke(us);
        } 
        catch (Exception e) 
        {
            System.out.println("No Such Service!");
        }
    }
}

*：Hibernate等持久层框架中的万能DAO层实现就是基于方法的反射。

4.从反射理解泛型

package com.hxy;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class GenericReflect 
{
    public static void main(String[] args)
    {
        ArrayList<String> list1 = new ArrayList<String>();
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1 == c2);
        //true
        
        //结论：
        //反射的操作实际上是编译之后的操作
        //.class
        //集合泛型，是用来防止错误输入的，只在编译阶段有效
        
        //验证：
        try
        {
            System.out.println(list1.size());
            //0
            Method m = c1.getMethod("add", Object.class);
            //add一个数字而不是string
            m.invoke(list1, 666);
            System.out.println(list1.size());
            //1
            //所以说：反射的操作实际上是编译之后的操作，不受编译阶段检查
            //且泛型只在编译阶段有效
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}