14 类型信息 Typeinfo

运行时类型信息使得你可以在程序运行时发现和使用类型信息

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");

可以修改成员的内容