运行时类型信息使得你可以在程序运行时发现和使用类型信息
RTTI
List<Parent> list = Arrays.asList( new Child1(), new Child2(), new Child3());
for(Parent p : list)
p.display();
这里List容器将创建的对象全部转型为Parent类型,当用for把对象取出的时候,也是Parent类型,当对具体某一个Parent对象执行
方法display的时候,就会根据具体对象所对应自类型中覆写的方法来调用,这就是多态
这个将所有对象转化为一个基类对象的形式,就是RTTI,它表示在运行时进行类型转化
- Class对象
Java使用Class对象来执行其RTTI,用Class对象来创建所有的常规对象
类是程序的一部分,每个类都有一个Class对象,也就是说,每当编译了一个新类,就会产生一个Class对象,为了生成这个对象,
JVM将使用“类加载器”这个子系统
有一个原生加载器,它是JVM实现的一部分,用来加载可信类,包括Java API类
所有的类都是在第一次对它进行使用时,动态地加载到JVM中的,当程序创建第一个对类的静态成员的引用时,就会加载这个类
因此,Java程序在它运行之前并非完全被加载,各个部分是在必要的时候才被加载的
类加载器首先会检查这个类的Class对象是否已经加载,如果尚未加载,默认的类加载器会根据类名查找.class文件,在这个类的字
节码被加载时,它们会自动接受验证,以确保其没有被破坏
一旦一个类的Class对象被载入内存,它就被用来创建这个类的所有对象
Class类
public static Class forName(String className); 用以获取Class对象,这里必须写全限定的类名
public boolean isInterface(); 判断一个类是不是接口
public String getSimpleName(); 返回一个类的不包含包名的类名
public String getCanonicalName(); 返回一个类的全限定类名
public Class getInterfaces(); 以类的形式返回一个类包含的接口
public Object newInstance(); 一种虚拟构造器,虚拟构造器允许你声明,不知道对象的具体类型,但允许你创建,直接创建成一个
Object类的引用,但这个引用指向的是已知某个具体类型的对象
- 字面量常量
用className.class来生成Class对象的引用
它在编译时就会被检查,所以不用try检查异常
.TYPE是一个引用,指向Class对象的引用
boolean.class == Boolean.TYPE
char.class = Character.TYPE
byte.class = Byte.TYPE
short.class = Short.TYPE
int.class = Integer.TYPE
long.class = Long.TYPE
float.class = Float.TYPE
double.class = Double.TYPE
void.class = Void.TYPE
用.class方式创建Class对象的引用时,不会自动地初始化Class对象
为了使用类包含三个步骤
1.加载。使用类加载器,查找字节码,并从这些字节码中创建一个Class对象
2.链接。验证类中的字节码,为静态域分配空间
3.初始化。如果该类具有超类,则对其进行初始化,对静态区域初始化
- 泛化Class引用
Class<T> t = T.class;
t = U.class;会出错,只能指向它声明的类型
使用通配符?可以放松这种限制
Class<?> intClass = int.class;
intClass = double.class;
还可以给出一个范围
Class<? extends Number> numClass = int.class;
numClass = double.class;
numClass = Number.class;
- 转型语法
Parent p = new Parent();
Class<Child> c = Child.class;
Child c1 = c.cast(p);
类型转换前先做检查
RTTI的形式包括
1.传统的类型转化,如(Parent),由RTTI保证转换的正确性,如果执行了错误的转换,就会抛出一个ClassCastException异常
2.代表对象的类型的Class对象,通过对Class对象的查询可以获取所需的类型信息
子类型向父类型的转换,一定成立,所以可以自动地进行这种向上转型,而不需要任何显式的转型操作
而父类型向自类型的向下转型,由于编译器只知道这是一个父类型对象,不知道是具体哪个子类型,因此编译器不允许你执行向下
转型的赋值,除非你使用第一种方式,显式地执行向下转型的操作
3.instanceof,它返回一个布尔值,表示对象是不是某个具体类型的实例
if(x instanceof Dog)
((Dog)x.bark());
动态的instanceof()
Class对象可以动态调用一个isinstance方法
public boolean isinstance(Object obj);
- isAssignableFrom()
用Class.isAssignableFrom();判断一个类型是不是当前这个Class类型或者其子类型,可以用于计数
public boolean isAssignableFrom(Class c);
public void countClass(Class<?> type) {
Integer quantity = get(type);
put(type,quantity == null ? 1 : quantity + 1);
Class<?> superClass = type.getSuperclass();
if(superClass!=null &&
baseType.isAssignableFrom(type)
countClass(superClass);
}
这里通过对一个类型的基类的检查,得知它是否是baseType类型或其子类,递归来为这个类型计数
注册工厂
public interface Factory<T> { T create(); }
class Part {
static List<Factory<? extends Part>> partFactories =
new ArrayList<Factory< ? extends Part>>();
static {
partFactories.add(new Filter.Factory());
}
public static Part createRandom() {
Randdom rand = new Random(47);
int n = rand.nextInt();
return partFactories.get(n).create();
}
}
class Filter extends Part {
public static class Factory
implements typeinfo.Factory {
public Filter create() {
return new Filter();
}
}
}
创建带泛型的工厂接口,对于基类的每一个派生类,在其内部实现工厂接口的一个静态内部类,用以创建派生类的对象,
在基类中创建Factory泛型的List,可以向里面通过创建派生类的工厂对象,再创建出具体派生类的对象
注意,isInstance(x)或者x instanceof A都表示你是这个类吗,你是这个类的派生类吗
而==或者equals只表示你是这个类吗,不会考虑到继承
反射:运行时的类信息
RTTI可以告诉你关于类的信息,但有一个条件是这个类型在编译时必须已知,如果是用像forName()这样的方法创建的Class对象,
无法在编译时得到类型信息的话,Class类与java.lang.reflect类库一起对反射的概念进行了支持
这些类包括了Method,Constructor,这些对象都是在JVM运行时创建的Class.getMethods(),Class.getConstructors(),getFields()
这些信息在运行时才去确定,在编译时不需要知道任何的信息
RTTI和反射真正的区别在于,在用RTTI做任何事情之前,必须先加载那个类的Class对象,因此,那个类的.class文件对于JVM来说
必须是可获取的,编译器在编译时打开和检查.class文件,而对于反射机制来说,.class文件在编译时是不可获取的,所以是在运行
时检查.class文件
动态代理
代理是你为了提供额外的或不同的操作,而插入的用来代替实际对象的对象
interface Interface implements Interface {
public void doSomething();
public void doSomethingElse();
}
class RealObject implements Interface {
public void doSomething() {}
public void doSomethingElse() {}
}
public static void consumer(Interface interface) {
iface.something();
iface.somethingElse();
}
- 动态代理
动态代理是反射的一部分
Proxy类
public static XXX newProxyInstance(ClassLoader XXX.class.getClassLoader, new Class[] { XXX.class }, InvocationHandler invocationHandler);
这个方法可以创建动态代理,它需要一个类加载器,一个你希望实现的接口列表(不是类或者抽象类),以及InvocationHandler几
口的一个实现,构造这个实现的时候一般会传递给它一个实际的对象引用,以便调用方法,这里生成一个代理对象XXX,调用方法
时会重定向到实现类的调用处理器中,就是这个
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}
当你使用xxx.f(args)的时候,就会把代理对象和你要调用的方法f传递进来,还有方法中的参数,
因为创建这个代理的时候,传递了一个实际的对象进来
在这个方法中,method.invoke(proxy,args)的时候会识别调用实际对象的方法
这个实现长这样
Class DynamicProxyHandler implements InvacationHandler {
//传递进来一个具体的对象引用
private Object proxied;
//构造的时候把这个对象传递进来
public DynamicProxyHandler(Object proxied) { this.proxied = proxied; }
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//这里传递进来的是代理对象
return method.invoke(proxied, args);
//这里调用的proxied是实际的对象
}
}
这里method.invoke(obj, args)把这个方法的调用请求用具体对象作为object,把参数传递进来
- 空对象
public interface Null {}
class Person {
public static class NullPerson extends Person implements Null { }
public static final Person NULL = new NullPerson();
}
class Position {
private Person person;
public Position() {
person = Person.NULL;
}
}
创建一个空对象接口,使用空对象来初始化未定义的内容,它可以响应实际对象可以响应的所有消息
- 使用代理创建空对象
class NullRobotProxyHandler implements InvocationHandler {
private String nullName;
private Robot proxied = new NRobot();
NullRobotProxyHandler(Class<? extends Robot> { nullName = type.getSimpleName() + "NullRobot"; }
private class NRobot implements Null,Robot {
pulblic String name() { return nullName; }
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return method.invoke(proxied, args);
}
}
public class NullRobot {
public static Robot newNullRobot(Class<? extends Robot> type) {
return (Robot)Proxy.newProxyInstance(
NullRobot.class.getClassLoader(),
new Class[] {Null.class,Robot.class},
new NullRobotProxyHandler(SnowRemovalRobot.class)
);
}
}
接口与类型信息
接口的目标之一就是允许程序员隔离构件,但通过类型信息,着这种耦合性还是会传递出去
Interface A { void f() {} }
class B implements A { public void f() {} public void g() {} }
class Test {
public static void main(String[] args) {
A a = new B();
a.f();
if(a instanceof B) {
a.g();
}
}
}
当以A类声明的对象a是通过B实现的,当它转型为B时,就可以调用B中特有的方法g()
利用反射,只要知道成员的名称,可以调用到类里任何的类,修改类里面的任何成员,即使是私有内部类,匿名内部类内的成员也一样,
唯一不会被修改的只有final的成员
static void callHiddenMethod(Object a, String methodName) {
Method g = a.getClass().getDeclaredMethod(methodName);
g.setAccess(true);
g.inboke(a);
}
g.setAccess(true);可以获得当前方法的访问权限,即使是换成其他成员也是一样
Field f = a.getClass().getDeclaredField(fieldName);
f.setAccess(true);
f.set(a,"xxxx");
可以修改成员的内容