《Java高级技术》课程 - è½¯ä»¶å·¥ç¨‹ç ”ç©¶æ‰€- 北京大学

《Java 高 级 技 术 》 课 程
Java 语 言 的 高 级 特 性 (8)
李 戈
北 京 大 学 信 息 科 学 技 术 学 院 软 件 研 究 所
2008 年 5 月 11 日

运 行 期 类 型 识 别
• RTTI ( Run-Time Type Identification )
在 运 行 期 间 , 识 别 一 个 对 象 的 类 型 。

运 行 期 类 型 识 别
• RTTI 的 三 种 方 法
强 制 类 型 转 换
利 用 Class 对 象
通 过 比 较 识 别 类 型

(1) 利 用 强 制 类 型 转 换 判 别 运 行 期 类 型
class Shape {
void draw() { System.out.println ( this + ".draw()"); }
}
class Circle extends Shape {
public String toString() { return "Circle"; }
}
class Square extends Shape {
public String toString() { return "Square"; }
}
class Triangle extends Shape {
public String toString() { return "Triangle"; }
}
public class Shapes {
public static void main(String[] args) {
// Array of Object, not Shape:
Object[ ] shapeList = { new Circle(), new Square(), new Triangle() };
for (int i = 0; i < shapeList.length; i++)
((Shape) shapeList[i]).draw();
}
}

• 强 制 类 型 转 换 并 不 彻 底
问 题
Object 被 转 型 为 Shape, 而 不 是 转 型 为 Circle, Square,
或 者 Triangle。
• 假 如 能 够 知 道 某 个 引 用 的 确 切 类 型 , 则 可 以 进 行 更
加 个 性 化 的 处 理
程 序 中 有 一 段 代 码 用 来 旋 转 列 表 中 的 所 有 图 形 , 但 你
想 跳 过 圆 形 , 因 为 对 圆 形 作 旋 转 没 有 意 义 。 如 果 你 可
以 获 取 到 某 个 Shape 引 用 所 指 向 的 对 象 的 确 切 类 型 ,
就 可 以 选 择 或 者 剔 除 这 个 特 例 。
• 那 么 , 类 型 信 息 在 运 行 期 是 如 何 表 示 的 ?

• Class 对 象
类 型 信 息 的 表 示 方 式
对 象 的 类 型 信 息 是 由 被 称 为 Class 对 象 的 特 殊
对 象 表 达 ;
Class 对 象 描 述 了 运 行 中 的 classes 和 interfaces
的 相 关 信 息 ; 通 过 Class 对 象 可 以 在 运 行 中 取
得 这 些 信 息 ;
Class 对 象 被 用 来 创 建 类 的 “ 常 规 ” 对 象 ;
每 个 类 都 有 一 个 Class 对 象 , 保 存 在 与 其 同 名
的 .class 文 件 中 ;
所 有 Class 对 象 都 属 于 Class 类 ;

• Class 对 象 的 作 用
类 型 信 息 的 表 示 方 式
在 运 行 期 间 , 一 旦 我 们 想 生 成 某 个 类 的 一 个 对
象 :
● 运 行 这 个 程 序 的 Java 虚 拟 机 (JVM) 首 先 检 查
这 个 类 的 Class 对 象 是 否 已 经 加 载 。
● 如 果 尚 未 加 载 ,JVM 就 会 根 据 类 名 查 找 .class
文 件 , 并 将 其 载 入 。
● 一 旦 某 个 类 的 Class 对 象 被 载 入 内 存 , 它 就 被 用
来 创 建 这 个 类 的 所 有 对 象 。

• 步 骤 :
(2) 利 用 Class 对 象 识 别 对 象 的 类 型
获 取 某 个 对 象 的 Class 对 象 ;
获 取 Class 对 象 中 的 类 型 相 关 信 息 ;
● Class 类 的 getName() : 以 String 的 形 式 返 回 此 Class
对 象 所 表 示 的 实 体 ( 类 、 接 口 、 数 组 类 、 基 本 类 型 或
void) 名 称 。
例 如 :
void printClassName(Object obj) {
System.out.println("The class of " + obj + " is " +
obj.getClass().getName());
}

类 型 信 息 的 获 取 方 式
• 如 何 获 取 一 个 class 的 Class 对 象
通 过 Object.getClass( ) 方 法 来 获 得
通 过 Class.forName( ) 方 法 获 得
通 过 类 字 面 常 量 (Class Literals) 获 得

类 型 信 息 的 获 取 方 式
• 通 过 Class.forName( ) 方 法 获 得
Class 类 的 forName( ) 方 法
forName(String className) : 返 回 与 带 有 给 定
字 符 串 名 的 类 或 接 口 相 关 联 的 Class 对 象 。
例 如 :
class Dog {………..}
Class referencetodog = Class.forName(“Dog”);

类 型 信 息 的 获 取 方 式
• 通 过 类 字 面 常 量 (Class Literals) 获 得
字 面 常 量 的 形 式 为 :classname.class。
对 于 基 本 类 型 , 每 种 基 本 类 型 的 包 装 类 都 有 一
个 名 为 TYPE 的 标 准 数 据 , 能 够 产 生 一 个 指 向
相 应 的 基 本 类 型 的 Class 对 象 的 引 用 。
● Integer.TYPE 等 同 于 int.class
例 如 :
class dog {………..}
Class referencetodog = dog.class;

class Cat {
Cat( ) {
System.out.println("Init Cat()");
}
static {
System.out.println("Loading Cat");
}}
class Dog {
Dog( ) {
System.out.println("Init Dog()");
}
static {
System.out.println("Loading Dog");
}}
class Duck {
Duck( ) {
System.out.println("Init Duck()");
}
static {
System.out.println("Loading Duck");
}}
in main()
Loading Cat
Init Cat()
After create Cat()
Loading Dog
After Class.forName("Dog")
Loading Duck
Init Duck()
After create Duck()
After d.getClass("Duck")

public class LetterClass {
public static void main(String[] args) {
System.out.println("in main()");
new Cat();
System.out.println("After create Cat()");
try {
Class c1 = Class.forName("Dog");
//System.out.println(c1.getName());
Class c2 = Dog.class;
//System.out.println(c2.getName());
} catch (ClassNotFoundException cnfe) {
cnfe.printStackTrace();
}
System.out.println("After Class.forName(\"Dog\")");
Duck d = new Duck();
System.out.println("After create Duck()");
Class c3 = d.getClass();
//System.out.println(c3.getName());
System.out.println("After d.getClass(\"Duck\")");
}
}

(3) 通 过 比 较 识 别 对 象 类 型
• 比 较 的 方 式
直 接 比 较 ;
利 用 isInstance( ) 函 数 进 行 比 较 ;
利 用 isinstanceof 操 作 符 进 行 比 较 ;

• 类 型 直 接 比 较 的 方 法
boolean equals(Object obj)
直 接 比 较
指 示 其 他 某 个 对 象 是 否 与 此 对 象 “ 相 等 ”。
A.equals(B);
利 用 == 运 算 符 进 行 比 较
If the operands of an equality operator are both of
either reference type or the null type, then the
operation is object equality.
注 意 : 两 个 Class 对 象 不 论 是 通 过 equals() 函 数 还 是 直
接 用 == 运 算 符 进 行 比 较 , 比 较 的 都 是 类 型 是 否 相 同 。

利 用 isInstance( ) 函 数 进 行 比 较
• boolean isInstance(Object obj)
判 定 指 定 的 Object 是 否 与 此 Class 所 表 示 的 对 象
赋 值 兼 容
class Cat{ }
class Dog{ }
class Duck{ }
public class Test{
public static void main(String[] args){
Class c2, c3;
Duck d = new Duck();
c2 = Dog.class;
c3 = d.getClass();
}
}
运 行 结 果 为 :
c2.isIntance(d):false
c3.isIntance(d):true
System.out.println("c2.isIntance(d):" + (c2.isInstance(d)));
System.out.println("c3.isIntance(d):" + (c3.isInstance(d)));

• instanceof
利 用 instanceof 操 作 符 进 行 比 较
Java 语 言 的 保 留 字 , 用 于 检 测 一 个 对 象 引 用 是 否 是 某 个 类
的 实 例 ; 当 这 个 对 象 引 用 的 类 型 是 这 个 类 或 者 是 这 个 类 的
子 类 型 时 返 回 true, 否 则 返 回 false。
class Cat{ }
class Dog{ }
class Duck{ }
public class Test{
public static void main(String[] args){
Class c3;
Object d = new Duck();
// Duck d = new Duck(); ?????
c3 = d.getClass();
System.out.println("d instanceof Dog:" + (d instanceof Dog));//(3)
}
}

• RTTI 有 一 个 限 制
问 题
对 象 的 类 型 在 编 译 期 必 须 是 已 知 的 ,
但 是 假 设 你 获 取 了 一 个 指 向 某 个 并 不 在 你 的 程
序 空 间 中 的 对 象 的 引 用 。
● 例 如 , 假 设 你 从 磁 盘 文 件 , 或 者 网 络 连 接 中 获
取 了 一 串 字 节 , 并 且 你 被 告 知 这 些 字 节 代 表 了
一 个 类 。 编 译 器 在 编 译 你 的 程 序 代 码 的 时 候 不
可 能 了 解 有 关 这 个 在 后 面 才 会 出 现 的 类 的 信 息 。
你 怎 样 才 能 使 用 这 样 的 类 呢 ?

• Class 类 支 持 反 射 的 概 念 ,
反 射 (Reflection)
Java 附 带 的 库 java.lang.reflect 包 含 了 Field,Method 以
及 Constructor 类 。 这 些 类 型 的 对 象 是 由 JVM 在 运 行 期
创 建 的 , 用 以 表 示 未 知 类 里 对 应 的 成 员 。
可 以 实 现 :
● 使 用 Constructor 创 建 新 的 对 象 ;
● 用 get() 和 set() 方 法 读 取 和 修 改 与 Field 对 象 关 联 的 属 性 ,
● 用 invoke() 方 法 调 用 与 Method 对 象 关 联 的 方 法 ;
● 调 用 getFields(),getMethods(),getConstructors() 方
法 , 以 返 回 表 示 属 性 、 方 法 以 及 构 造 器 的 对 象 数 组 ;
匿 名 对 象 的 类 信 息 就 能 在 运 行 期 被 完 全 确 定 下 来 , 而
在 编 译 期 不 需 要 知 道 任 何 事 情 。

反 射 (Reflection)
• Java 反 射 机 制 主 要 提 供 了 以 下 功 能 :
在 运 行 时 判 断 任 意 一 个 对 象 所 属 的 类 ;
在 运 行 时 构 造 任 意 一 个 类 的 对 象 ;
在 运 行 时 判 断 任 意 一 个 类 所 具 有 的 成 员 变 量
和 方 法 ;
在 运 行 时 调 用 任 意 一 个 对 象 的 方 法 ;
生 成 动 态 代 理 。

反 射 (Reflection)
• JDK 中 主 要 由 以 下 类 实 现 Java 反 射 机 制 :
Class 类 : 其 实 例 表 示 正 在 运 行 的 Java 应 用 程 序 中 的
类 和 接 口 。
Field 类 : 提 供 有 关 类 或 接 口 的 单 个 字 段 的 信 息 , 以 及
对 它 的 动 态 访 问 权 限 ;
Method 类 : 提 供 关 于 类 或 接 口 的 某 个 方 法 ( 以 及 如
何 访 问 该 方 法 ) 的 信 息 ;
Constructor 类 : 提 供 关 于 类 的 单 个 构 造 方 法 的 信 息
以 及 对 它 的 访 问 权 限 ;
Array 类 : 提 供 了 动 态 创 建 和 访 问 Java 数 组 的 方 法 。

import java.lang.reflect.*;
例 1: 获 取 类 信 息
public class DumpMethods {
public static void main(String args[]) throws Exception {
// 加 载 并 初 始 化 命 令 行 参 数 指 定 的 类
Class classType = Class.forName(args[0]);
// 获 得 类 的 所 有 方 法
Method methods[] = classType.getDeclaredMethods();
for (int i = 0; i < methods.length; i++)
System.out.println(methods[i].toString());
}
}
输 入 :java DumpMethods java.util.Stack
输 出 :
public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)

import java.lang.reflect.*;
public class InvokeTester {
public int add(int param1, int param2) {
return param1 + param2;
}
public String echo(String msg) {
return "echo:" + msg;
}
public static void main(String[] args) throws Exception {
Class classType = InvokeTester.class;
Object invokeTester = classType.newInstance();
// 调 用 InvokeTester 对 象 的 add() 方 法
Method addMethod = classType.getMethod("add", new Class[] { int.class,
int.class });
Object result = addMethod.invoke(invokeTester, new Object[] {
new Integer(100), new Integer(200) });
System.out.println((Integer) result);
// 调 用 InvokeTester 对 象 的 echo() 方 法
Method echoMethod = classType.getMethod("echo",
new Class[] { String.class });
result = echoMethod.invoke(invokeTester, new Object[] { "Hello" });
System.out.println((String) result);
}}
例 2: 调 用 类 方 法

import java.lang.reflect.*;
public class InvokeTester {
public int add(int param1, int param2) {
return param1 + param2;
}
public String echo(String msg) {
return "echo:" + msg;
}
public static void main(String[] args) throws Exception {
Class classType = InvokeTester.class;
Object invokeTester = classType.newInstance();
// 调 用 InvokeTester 对 象 的 add() 方 法
Method addMethod = classType.getMethod("add", new Class[] { int.class,
int.class });
Object result = addMethod.invoke(invokeTester, new Object[] {
new Integer(100), new Integer(200) });
System.out.println((Integer) result);
// 调 用 InvokeTester 对 象 的 echo() 方 法
Method echoMethod = classType.getMethod("echo",
new Class[] { String.class });
result = echoMethod.invoke(invokeTester, new Object[] { "Hello" });
System.out.println((String) result);
}}
例 2: 调 用 类 方 法

Customer 类 是 一 个 JavaBean
class Customer {
private Long id;
private String name;
private int age;
public Customer() { }
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public Long getId() { return id; }
public void setId(Long id) { this.id = id; }
public String getName() { return name; }
}
例 3: 综 合 应 用
目 标 : 构 造 一 个 copy(Object object) 方
法 , 这 个 方 法 能 够 创 建 一 个 和 参 数
object 同 样 类 型 的 对 象 , 并 把 object
对 象 中 的 所 有 属 性 复 制 到 新 建 的 对
象 中 , 并 将 它 返 回 。
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }

import java.lang.reflect.*;
public class ReflectTester {
public Object copy(Object object) throws Exception {
// 获 得 对 象 的 类 型
Class classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通 过 默 认 构 造 方 法 创 建 一 个 新 的 对 象
Object objectCopy =
classType.getConstructor(new Class[] {}).newInstance(new Object[] {});
// 获 得 对 象 的 所 有 属 性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
……
}
return objectCopy;
}
}
public static void main(String[] args) throws Exception {
……
}

import java.lang.reflect.*;
public class ReflectTester {
public Object copy(Object object) throws Exception {
// 获 得 对 象 的 类 型
Class classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通 过 默 认 构 造 方 法 创 建 一 个 新 的 对 象
Object objectCopy = classType.getConstructor(new Class[] {})
.newInstance(new Object[] {});
// 获 得 对 象 的 所 有 属 性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
// 获 得 和 属 性 对 应 的 getXXX() 方 法 的 名 字
String getMethodName = "get" + firstLetter + fieldName.substring(1);
// 获 得 和 属 性 对 应 的 setXXX() 方 法 的 名 字
String setMethodName = "set" + firstLetter + fieldName.substring(1);
// 获 得 和 属 性 对 应 的 getXXX() 方 法
Method getMethod = classType.getMethod(getMethodName,
new Class[] {});
// 获 得 和 属 性 对 应 的 setXXX() 方 法
Method setMethod = classType.getMethod(setMethodName,
new Class[] { field.getType() });
// 调 用 原 对 象 的 getXXX() 方 法
Object value = getMethod.invoke(object, new Object[] {});
System.out.println(fieldName + ":" + value);
// 调 用 复 制 对 象 的 setXXX() 方 法
setMethod.invoke(objectCopy, new Object[] { value });
}
return objectCopy;
}
public static void main(String[] args) throws Exception {
}
}

import java.lang.reflect.*;
public class ReflectTester {
public Object copy(Object object) throws Exception {
// 获 得 对 象 的 类 型
Class classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通 过 默 认 构 造 方 法 创 建 一 个 新 的 对 象
Object objectCopy = classType.getConstructor(new Class[] {})
.newInstance(new Object[] {});
// 获 得 对 象 的 所 有 属 性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
// 获 得 和 属 性 对 应 的 getXXX() 方 法 的 名 字
String getMethodName = "get" + firstLetter + fieldName.substring(1);
// 获 得 和 属 性 对 应 的 setXXX() 方 法 的 名 字
String setMethodName = "set" + firstLetter + fieldName.substring(1);
// 获 得 和 属 性 对 应 的 getXXX() 方 法
Method getMethod = classType.getMethod(getMethodName,
new Class[] {});
// 获 得 和 属 性 对 应 的 setXXX() 方 法
Method setMethod = classType.getMethod(setMethodName,
new Class[] { field.getType() });
// 调 用 原 对 象 的 getXXX() 方 法
Object value = getMethod.invoke(object, new Object[] {});
System.out.println(fieldName + ":" + value);
// 调 用 复 制 对 象 的 setXXX() 方 法
setMethod.invoke(objectCopy, new Object[] { value });
}
return objectCopy;
}
}
public static void main(String[] args) throws Exception {
Customer customer = new Customer("Tom", 21);
customer.setId(new Long(1));
Customer customerCopy
= (Customer) new ReflectTester().copy(customer);
System.out.println("Copy information:" + customerCopy.getName() + ""
+ customerCopy.getAge());
}

RTTI vs. Reflection
• 重 要 的 是 , 反 射 机 制 并 没 有 什 么 魔 法 。 当 你 通 过 反
射 与 一 个 未 知 类 型 的 对 象 打 交 道 时 ,JVM 只 是 简 单
地 检 查 这 个 对 象 , 看 它 属 于 哪 个 特 定 的 类 ( 就 象
RTTI 那 样 )。
• 在 这 之 后 , 在 做 其 它 事 情 之 前 , 必 须 加 载 那 个 类 的
Class 对 象 。 因 此 , 那 个 类 的 .class 文 件 对 于 JVM 来 说
必 须 是 可 获 取 的 , 要 么 在 本 地 机 器 上 , 要 么 可 以 通
过 网 络 取 得 。
• 所 以 RTTI 和 反 射 之 间 真 正 的 区 别 只 在 于 , 对 RTTI
来 说 , 编 译 器 在 编 译 期 打 开 和 检 查 .class 文 件 , 而 对
于 反 射 机 制 来 说 是 在 运 行 期 打 开 和 检 查 .class 文 件 。

好 好 想 想 , 有 没 有 问 题 ?
谢 谢 !