Java RTTI 和 反射机制

运行时，识别对象和类的信息有两种方法：

     1、RTTI

     2、“反射”机制

 

RTTI 即 Run Time Type Identification 运行时类型识别

在java中，RTTI表现在：

　　1、Class对象是RTTI的核心，每个类都有一个Class对象

　　2、instanceof 关键字，用于检查对象是不是某个特定类型的实例

　　3、强制类型转换

 

RTTI示例：

public class RTTITest {

    public static void main(String[] args) {
        Number n = 123L;

        //c1 c2 c3都是java.lang.Class类的对象
        Class<? extends Number> c1 = n.getClass();
        Class<Number> c2=Number. class;
        Class<Long> c3=Long. class;

        System. out.println(c1.getName());
        System. out.println(c2.getName());
        System. out.println(c3.getName());

        //== 和  equals()是等价的
        System. out.println((c1==c2)+" " +(c1.equals(c2)));
        System. out.println(c1.equals(c3));

        //instanceof 关键字和Class.isInstance等价的
        //指“你是这个类吗？或者 你是这个类的派生类吗？”
        System. out.println(n instanceof Number);
        System. out.println(Number.class.isInstance(n));
        System. out.println(n instanceof Long);
        System. out.println(Long.class.isInstance(n));
    }
}

输出：
java.lang.Long     ---- n.getClass().返回对象n运行时的Class对象，所以是Long.class，而不是Number.class
java.lang.Number
java.lang.Long

false false
true

true
true
true
true

Java语言的反射机制

使java具有动态语言的特性：动态获取类的信息、动态调用类的方法

 

Java反射机制提供一下功能:

　　1、运行时判断任意一个对象所属的类

　　2、运行时构造任意一个类的对象

　　3、运行时判读任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）

　　4、运行时调用任意一个对象的方法

 

Java反射机制相关的API简介（位于java.lang.reflect）

　　Class类：代表一个类

　　Field类：代表类的成员变量

　　Method类：代表类的方法

　　Constructor类：代表类的构造方法

 

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


class Person{
    private final String name;
    private int age = 20;
    private String sex;

    public Person(String name) {
        this.name = name;
    }
    public void sayHello(String name, int age) {
        System.out.println(name + "  " + age);
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
}

public class WatchClassInfo {

    public static void main(String[] args) throws Exception {
        Person person = new Person("Shao");
        person.setSex("man");
        Class<?> c = person.getClass();//获得运行时对象的类对象
        Class<?> superClass=person.getClass().getSuperclass();//获得运行时对象的基类类对象

        System.out.println("class loader : "+c.getClassLoader());
        System.out.println("class name : "+c.getName());
        System.out.println("super class name "+superClass.getName());


        System.out.println("-----------查看类中声明的数据成员，及其值-----------");
        Field[] fields=c.getDeclaredFields();//获得类的数据成员信息
        for (int i = 0; i < fields.length; i++) {
            Field field=fields[i];
            System.out.print(field.getType().getSimpleName()+" "+field.getName());

            String fieldName=field.getName();
            String upper=fieldName.substring(0, 1).toUpperCase();
            String getName="get"+upper+fieldName.substring(1);
            Method getMethod=c.getMethod(getName, new Class[]{});

            Object fieldValue=getMethod.invoke(person,new Object[]{});//在person对象上调用getter方法
            System.out.println(" = "+fieldValue);
        }


        System.out.println("-----------查看类中声明的方法-------------------");
        Method method[] = c.getDeclaredMethods();//获得类的方法信息
        for (int i = 0; i < method.length; ++i) {
            Class<?> returnType = method[i].getReturnType();
            Class<?> para[] = method[i].getParameterTypes();
            int temp = method[i].getModifiers();
            System.out.print(Modifier.toString(temp) + " "+returnType.getName() + "  "+method[i].getName() + " "+"(");

            for (int j = 0; j < para.length; ++j) {
                System.out.print(para[j].getName() + " " + "arg" + j);
                if (j < para.length - 1) {
                    System.out.print(",");
                }
            }
            System.out.println(")");
        }
    }

}

输出：
class loader : sun.misc.Launcher$AppClassLoader@addbf1
class name : edu.shao.typeinfo.reflect.Person
super class name java.lang.Object
-----------查看类中声明的数据成员，及其值-----------
String name = Shao
int age = 20
String sex = man
-----------查看类中声明的方法-------------------
public void  setSex (java.lang.String arg0)
public void  sayHello (java.lang.String arg0,int arg1)
public int  getAge ()
public void  setAge (int arg0)
public java.lang.String  getSex ()
public java.lang.String  getName ()

RTTI和反射之间真正的区别在于：

　　1、对于RTTI来说，编辑器在编译时打开或检查.class文件。换句话说，我们可以用“普通”方法调用对象的所有方法。

　　2、对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。