读Java编程思想随笔の类型信息

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

　　它使你从只能在编译期执行面向类型的操作的禁锢中解脱出来，并且可以使用某些非常强大的程序。对于RTTI的需要，揭示了面向对象的设计中许多有趣的问题，同时也提出了如何组织程序的问题。

　　如何让我们在执行程序时识别对象和类的信息，主要有两种方式：一，“传统的”RTTI，它假定我们在编译时已经知道了所有的类型；另一种是“反射”机制，它允许我么在运行时发现和使用类的信息。

　　为什么需要RTTI

　　

　　这是一个很熟悉的例子，它使用了多态的类层次结构。最通用的类型（泛型）是基类Shape，而派生出的具体有Circle、Square和Triangle。

　　这是一个典型的类层次结构图，基类位于顶部，派生类向下扩展。面向对象编程中基本的目的是：让代码只操作对基类的引用。这样，如果要添加一个新类来扩展程序，就不会影响到原来的代码。在这个例子中Shape动态绑定了draw()方法，目的就是为了让客户端程序使用泛化的Shape引用来调用draw()方法。draw()在所有派生类中都会被覆盖，并且由于它是动态绑定的，所以即使是通过泛化的Shape引用来调用，也能产生正确的行为。这就是多态。

　　因此，通常会创建一个具体的对象（Circle、Square或Triangle），把它向上转型为Shape，并在后面的程序中使用匿名的Shape引用。

public class Shapes {
        public static void main(String[] args) {
                List<Shape> shapeList = Arrays.asList(new Circle(),new Triangle(),new Square());
                for (Shape shape:shapeList){
                        shape.draw();
                }
        }
}
abstract class Shape{
        void draw (){
                System.out.println(this+".draw()");
        }
        abstract public String toString();//强制继承者复写该方法
}
class Circle extends Shape{

        @Override
        public String toString() {
                return "Circle";
        }
}
class Triangle extends Shape{

        @Override
        public String toString() {
                return "Triangle";
        }
}
class Square extends Shape{

        @Override
        public String toString() {
                return "Square";
        }
}
/**
 * 这是一个典型的类层次结构图，基类位于顶部，派生类向下扩展。面向对象编程基本目的是：让代码只操作基类的引用，
 * 这样，如果要添加一个新类来扩展程序，就不会影响原来的代码。在这个示例中，Shape接口动态绑定了draw()方法，
 * 目的就是让客户端程序员使用泛化的Shape引用来调用draw()。draw()在所有派生类里都会被覆盖，并且由于它是动态
 * 绑定的，所以即使通过泛化的Shape引用来调用，也能产生正确的行为。这就是多态。
 *
 * 在这个例子中，当把Shape对象放入List<Shape>数组时它会向上转型。但在向上转型为Shape类型时它也丢失了原来具体
 * 的类型。对于数组而言，它们只是Shape类的对象。
 *
 * 当从数组中取出元素时，实际上，这种容器它将所有对象都当做Object持有，并会自动转型为Shape。这是RTTI最基本的
 * 使用形式，因为在Java中，所有类型转换都是在运行时进行正确性检查的。这也是RTTI名字的含义：在运行时，识别一个
 * 对象的类型。
 *
 * 在这个例子中，RTTI类型转换并不彻底；Object被转型为Shape,而不是转型为Circle\Triangle\Square，这是因为目前
 * 我们只知道这个List<Shape>保存的都是Shape。在编译时，将由容器或泛型系统来确保这一点；而在运行时，由类型转换
 * 操作来确保这点。
 *
 * */

　　Class对象

　　要了解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的。这项工作是由Class对象这一特殊对象来完成的，它包含了与类有关的信息。事实上，Class对象就是用来创建类的所有的常规对象的。Java使用Class对象来执行其RTTI，即使你正在执行的是类似转型这样的操作。Class类还拥有大量的使用RTTI的其他方式。

　　类是程序的一部分，每个类都有一个Class对象。换言之，每当编写并且编译了一个新类，就会产生一个Class对象（更确切的说，是被保存在一个同名的.class文件中）。为了生成这个类的对象，运行这个程序的虚拟机将使用被称为“类加载器”的子系统。

　　类加载器子系统实际上可以包含一条类加载器链，但是只有一个原生类加载器，它是JVM实现的一部分。原生类加载器加载的是所谓的可信类，包括Java API类，它们通常是本地盘加载的。在这条链中，通常不需要添加额外的类加载器，但是如果你有特殊需求，那么你有一种方式可以挂接额外的类加载器。

　　所有的类都是在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态成员的引用时，就会加载这个类。这个证明构造器也是类的静态方法，即使在构造器之前并没有使用static关键字。因此，使用new操作符创建类的新对象也会被当作类的静态成员的引用。

　　类加载器首先确认类的Class对象是否已经被加载。如果尚未加载，默认的类加载器就会根据类名查找.class文件。在这个类的字节码被加载时，它们会接受验证，以确保其没有被破环，并且不包含不良Java代码。一旦某个类的Class对象被载入内存，它就被用来创建这个类的多有对象。

public class SweetShop {
        public static void main(String[] args) {
                System.out.println("inside main");
                new Candy();
                System.out.println("After creating Candy");
                try {
                        //new Gum();
                        Class.forName("Gum");
                } catch (ClassNotFoundException e) {
                        //e.printStackTrace();
                        System.out.println("Coundnt find Gum");
                }
                System.out.println("After Class.forName(\"Gum\")");
                new Cookie();
                System.out.println("After creating Cookie");
        }
}
class Candy{
        static {
                System.out.println("Loading Candy");
        }
}
class Gum{
        static {
                System.out.println("Loading Gum");
        }
}
class Cookie{
        static {
                System.out.println("Loading Cookie");
        }
}
//        inside main
//        Loading Candy
//        After creating Candy
//        Coundnt find Gum
//        After Class.forName("Gum")
//        Loading Cookie
//        After creating Cookie

/**
 * 要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的。这项工作是有
 * 称为Class对象的特殊对象完成的，它包含了与类有关的信息。事实上，Class对象用来创建类的
 * 常规对象。Java使用Class对象执行其RTTI，即使你正在执行的是类似转型这样的操作。Class类
 * 还拥有大量的使用RTTI的其他方式。
 *
 * 类是程序的一部分，每个类都有一个Class对象。换言之，每当编写并且编译了一个新类，就会产生
 * 一个Class对象（更恰当的说，是被保存在一个同名的.class文件中）。为了生成这个类的对象，运行
 * 这个程序的Java虚拟机将使用被称为类加载器的子系统。
 *
 * 类加载器子系统实际上包含了一条类加载器链，但是只有一个原生类加载器，它是JVM实现的一部分。
 * 原生类加载器加载的是所谓的可信类，包括Java API类，它们通常是从本地磁盘加载的。在这条链中
 * ，通常不需要添加额外的类加载器。
 *
 * 所有的类都是在对其第一次使用时，动态加载到JVM中，当程序创建第一个对类的静态成员的引用时
 * 就会加载这个类。这个证明构造器也是累的静态方法，即使在构造器之前并没有使用static关键字
 * 。因此，使用new操作符创建类的新对象也会被当做对类的静态成员的引用。
 *
 * 因此，Java程序在被运行之前并未被完全加载，其各个部分是必需时才加载的。这一点与许多传统语言
 * 都不同。
 *
 * 类加载器首先检查这个类的Class对象是否已经加载。如果尚未加载，默认的类加载器就会根据类名查找
 * .class文件。在这个类的字节码被加载时，它们会接受验证，以确保其没有被破坏，并且不包含不良代码
 *
 *
 * */

　　Class对象一些有用的方法

interface HasBatteries{}
interface Waterproof{}
interface Shoots{}
class Toy{
        Toy(){}
        Toy(int i){}
}
class FancyToy extends Toy implements HasBatteries,Waterproof,Shoots{
        FancyToy(){super(1);}
}
public class ToyTest {
        static void printInfo(Class cc){
                System.out.println("Class name:"+cc.getName()+" is interface?["+cc.isInterface()+"]");
                System.out.println("Simple name:"+cc.getSimpleName());
                System.out.println("Canonical name:"+cc.getCanonicalName());
        }

        public static void main(String[] args) {
                Class c = null;
                try {
                        c = Class.forName("com.qiqi.typeinfo.FancyToy");
                } catch (ClassNotFoundException e) {
                        // e.printStackTrace();
                        System.out.println("Cant find FancyToy");
                        System.exit(1);
                }
                printInfo(c);
                for (Class face:c.getInterfaces()){
                        printInfo(face);
                }
                Class up = c.getSuperclass();
                Object obj = null;
                try {
                        obj = up.newInstance();
                } catch (InstantiationException e) {
                        System.out.println("Cannot instantiate");
                        System.exit(1);
                } catch (IllegalAccessException e) {
                        System.out.println("Cannot access");
                        System.exit(1);
                }
                printInfo(obj.getClass());

        }
}
//        Class name:com.qiqi.typeinfo.FancyToy is interface?[false]
//        Simple name:FancyToy
//        Canonical name:com.qiqi.typeinfo.FancyToy
//        Class name:com.qiqi.typeinfo.HasBatteries is interface?[true]
//        Simple name:HasBatteries
//        Canonical name:com.qiqi.typeinfo.HasBatteries
//        Class name:com.qiqi.typeinfo.Waterproof is interface?[true]
//        Simple name:Waterproof
//        Canonical name:com.qiqi.typeinfo.Waterproof
//        Class name:com.qiqi.typeinfo.Shoots is interface?[true]
//        Simple name:Shoots
//        Canonical name:com.qiqi.typeinfo.Shoots
//        Class name:com.qiqi.typeinfo.Toy is interface?[false]
//        Simple name:Toy
//        Canonical name:com.qiqi.typeinfo.Toy

　　类字面常量

　　Java还提供了另一种方法来生成对Class对象的引用，即使用类字面变量。对上述程序来说就像这样：FancyToy.class；这样做不仅简单，而且更加安全，因为它在编译时就会受到检查（因此它不需要置于try语句块中）。并且它根除了对forName()的调用，所以也更高效。

　　类字面变量不仅可以用于普通的类，也可以应用于接口、数组以及基本数据类型。另外，对于基本数据类型的包装器类，还有一个标准字段TYPE。TYPE字段是一个引用，指向对应的基本数据类型Class对象。

　　我们建议使用.class的形式，以保持与普通类的一致性。

　　注意，当使用.class来创建对Class对象的引用时，不会自动地初始化该Class对象。为了使用类而作的准备工作实际包含三个步骤：

　　1、加载，这是由类加载器执行的（通常在classpath所指定的路径中查找，但这并非是必需的）。该步骤将查找字节码，并从这些字节码中创建一个Class对象；

　　2、链接，在链接阶段将验证类中的字节码，为静态域分配存储空间，并且如果必需的话，将解析这个类传几个I安的对其他类的所有引用；

　　3、初始化，如果该类具有超类，则对其初始化、执行静态初始化器和静态初始化块。

　　初始化被延迟到了对静态方法（构造器隐式地是静态的）或者非常数静态域进行首次引用时才执行

class Initable {
  static final int staticFinal = 47;
  static final int staticFinal2 =
    ClassInitialization.rand.nextInt(1000);
  static {
    System.out.println("Initializing Initable");
  }
}

class Initable2 {
  static int staticNonFinal = 147;
  static {
    System.out.println("Initializing Initable2");
  }
}

class Initable3 {
  static int staticNonFinal = 74;
  static {
    System.out.println("Initializing Initable3");
  }
}

public class ClassInitialization {
  public static Random rand = new Random(47);
  public static void main(String[] args) throws Exception {
    Class initable = Initable.class;
    System.out.println("After creating Initable ref");
    // Does not trigger initialization:
    System.out.println(Initable.staticFinal);
    // Does trigger initialization:
    System.out.println(Initable.staticFinal2);//强制进行初始化，因为staticFinal2不是一个编译器常量
    // Does trigger initialization:
    System.out.println(Initable2.staticNonFinal);
    Class initable3 = Class.forName("Initable3");//写全路径，并try catch
    System.out.println("After creating Initable3 ref");
    System.out.println(Initable3.staticNonFinal);
  }
} /* Output:
After creating Initable ref
47
Initializing Initable
258
Initializing Initable2
147
Initializing Initable3
After creating Initable3 ref
74
*///:~

 　　初始化有效地实现了尽可能的“惰性”。从对initable引用的创建中可以看到，仅使用.class方法来获得对类的引用不会引发初始化。但是，为了产生Class引用，Class.forName()立即就进行了初始化，就像在对initable3引用的创建中所看到的。

　　如果一个static final值是一个编译器常量，就像initable.staticFinal那样，那么这个值不需要对Initable类进行初始化就可以被读取。但是，如果只是将一个域设置为static和final，还不足以确保这种行为。例如，对initable.staticFinal2的访问将强制进行类的初始化，因为它不是一个编译器常量。

　　如果一个static域不是final的，那么在对它访问时，总是要求它在被读取之前，要先进行链接（为这个域分配存储空间）和初始化（初始化该存储空间），就像对initable2.staticNonFinal访问所看到的那样。

　　泛化的Class引用

　　Class引用总是指向某个Class对象，它可以制造类的实例，并包含可作用于这些实例的所有方法代码。它还包含该类的静态成员，因此，Class引用表示的就是它所指向的对象的确切类型，而该对象便是Class类的一个对象。

　　但是，Java SE5的设计者们看准了机会，将它的类型变的更具体了一些，而这是通过允许你对Class引用所指向的Class对象的类型进行限定而实现的，这里用到了泛型语法。

public class GenericClassReferences {

        public static void main(String[] args) {
                Class intClass = int.class;
                Class<Integer> genericIntClass = int.class;
                genericIntClass = Integer.TYPE;
                intClass = double.class;
                //加入了泛化的Class引用
                //genericIntClass = double.class;
        }
}

　　普通的类引用不会产生警告信息，你可以看到，尽管泛型类引用只能赋值为指向其声明的类型，但是普通的类引用可以被重新赋值为指向任何其他的Class对象。通过使用泛型语法，可以让编译器强制执行额外的类型检查。

　　为了在使用泛化的Class引用时放松限制。可以使用通配符，它是Java泛型的一部分。通配符就是“？”，表示“任何事物”。看下面示例。

public class WildcardClassReferences {
        public static void main(String[] args) {
                Class<?> intClass  = int.class;
                intClass = double.class;
        }
}

　　Class<?>的好处是它表示你并非是碰巧或者由于疏忽，而使用了一个非具体的类引用，你就是选择了非具体的版本。

　　为了创建一个Class引用，它被限定为某种类型，或该类型的任何子类型，你需要将通配符与extends关键字相结合，创建一个范围。

public class BoundedClassReferences {
        public static void main(String[] args) {
                Class<? extends Number> bounded = int.class;
                bounded = double.class;
                bounded = Number.class;
                //or anything else derived from Number
        }
}

　　下面的示例使用了泛型类语法。它存储了一个类引用，稍候又产生了一个List，填充这个List的对象是使用newInstance()方法，通过该引用生成的

public class FilledList<T> {
        private Class<T> type;
        public FilledList(Class<T> type){this.type = type;}
        public List<T> create(int nElement){
                List<T> list = new ArrayList<T>();

                for (int i=0;i<nElement;i++){
                        try {
                                list.add(type.newInstance());//引用实例化
                        } catch (InstantiationException e) {
                                e.printStackTrace();
                        } catch (IllegalAccessException e) {
                                e.printStackTrace();
                        }
                }
                return list;
        }

        public static void main(String[] args) {
                FilledList<CountedInteger> fl = new FilledList<CountedInteger>(CountedInteger.class);
                System.out.println(fl.create(15));
        }

}
class CountedInteger{
        private static long counter;
        private final long id = counter++;
        @Override
        public String toString() {
                return Long.toString(id);
        }
}
//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

　　类型转换前先做检查

　　RTTI形式包括：

　　1）传统的类型转换，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。

　　2）代表对象的类型的Class对象。通过查询Class对象可以获取运行时所需的信息。

　　3）使用关键字instanceof。它返回一个布尔值，告诉我们对象是不是某个特定类型的实例。

　　我们需要一种方法，通过它可以随机地创建不同类型的宠物，并且还可以创建宠物数组和List。

public abstract class PetCreator {
  private Random rand = new Random(47);
  // The List of the different types of Pet to create:
  public abstract List<Class<? extends Pet>> types();
  public Pet randomPet() { // Create one random Pet
    int n = rand.nextInt(types().size());
    try {
      return types().get(n).newInstance();
    } catch(InstantiationException e) {
      throw new RuntimeException(e);
    } catch(IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }    
  public Pet[] createArray(int size) {
    Pet[] result = new Pet[size];
    for(int i = 0; i < size; i++)
      result[i] = randomPet();
    return result;
  }
  public ArrayList<Pet> arrayList(int size) {
    ArrayList<Pet> result = new ArrayList<Pet>();
    Collections.addAll(result, createArray(size));
    return result;
  }
} ///:~

 　　抽象的types()方法在导出类中实现，以获取由Class对象构成的List。注意，其中类的类型被指定为“任何从Pet导出的类”，因此，newInstance()不需要转型就可以产生Pet。randomPet()随机地产生List中的索引，并使用被选取的Class对象，通过Class.newInstance()来生成该类的新实例。createArray()方法使用randomPet()来填充数组，而arrayList()方法使用的则是createArray()。

　　下面是使用forName()的一个具体实现

public class Individual implements Comparable<Individual> {
  private static long counter = 0;
  private final long id = counter++;
  private String name;
  public Individual(String name) { this.name = name; }
  // 'name' is optional:
  public Individual() {}
  public String toString() {
    return getClass().getSimpleName() +
      (name == null ? "" : " " + name);
  }
  public long id() { return id; }
  public boolean equals(Object o) {
    return o instanceof Individual &&
      id == ((Individual)o).id;
  }
  public int hashCode() {
    int result = 17;
    if(name != null)
      result = 37 * result + name.hashCode();
    result = 37 * result + (int)id;
    return result;
  }
  public int compareTo(Individual arg) {
    // Compare by class name first:
    String first = getClass().getSimpleName();
    String argFirst = arg.getClass().getSimpleName();
    int firstCompare = first.compareTo(argFirst);
    if(firstCompare != 0)
    return firstCompare;
    if(name != null && arg.name != null) {
      int secondCompare = name.compareTo(arg.name);
      if(secondCompare != 0)
        return secondCompare;
    }
    return (arg.id < id ? -1 : (arg.id == id ? 0 : 1));
  }
} ///:~
public class Pet extends Individual {
  public Pet(String name) { super(name); }
  public Pet() { super(); }
} ///:~
public abstract class PetCreator {
  private Random rand = new Random(47);
  // The List of the different types of Pet to create:
  public abstract List<Class<? extends Pet>> types();
  public Pet randomPet() { // Create one random Pet
    int n = rand.nextInt(types().size());
    try {
      return types().get(n).newInstance();
    } catch(InstantiationException e) {
      throw new RuntimeException(e);
    } catch(IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }    
  public Pet[] createArray(int size) {
    Pet[] result = new Pet[size];
    for(int i = 0; i < size; i++)
      result[i] = randomPet();
    return result;
  }
  public ArrayList<Pet> arrayList(int size) {
    ArrayList<Pet> result = new ArrayList<Pet>();
    Collections.addAll(result, createArray(size));
    return result;
  }
} ///:~
public class ForNameCreator extends PetCreator {
  private static List<Class<? extends Pet>> types =
          new ArrayList<Class<? extends Pet>>();
  // Types that you want to be randomly created:
  private static String[] typeNames = {
          "typeinfo.pets.Mutt",
          "typeinfo.pets.Pug",
          "typeinfo.pets.EgyptianMau",
          "typeinfo.pets.Manx",
          "typeinfo.pets.Cymric",
          "typeinfo.pets.Rat",
          "typeinfo.pets.Mouse",
          "typeinfo.pets.Hamster"
  };
  @SuppressWarnings("unchecked")
  private static void loader() {
    try {
      for(String name : typeNames)
        types.add(
                (Class<? extends Pet>)Class.forName(name));
    } catch(ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }
  static { loader(); }
  public List<Class<? extends Pet>> types() {return types;}
} ///:~

　　loader()方法用Class.forName()创建了Class对象的List，这可能会产生ClassNotFoundException异常，这么做事有意义的，因为你传递给它的是一个在编译期无法验证的String。由于Pet对象在typeinfo包中，因此必须使用包名来引用这些类。

　　为了产生具有实际类型的Class对象的List，必须使用转型，这会产生编译期警告。loader()方法被单独定义，然后被置于一个静态初始化子句中，因为@SuppressWarnings("unchecked")注解不能直接置于静态初始化子句之上。

　　使用instanceof来对Pet进行计数

public class PetCount {
  static class PetCounter extends HashMap<String,Integer> {
    public void count(String type) {
      Integer quantity = get(type);
      if(quantity == null)
        put(type, 1);
      else
        put(type, quantity + 1);
    }
  }    
  public static void
  countPets(PetCreator creator) {
    PetCounter counter= new PetCounter();
    for(Pet pet : creator.createArray(20)) {
      // List each individual pet:
      System.out.println(pet.getClass().getSimpleName() + " ");
      if(pet instanceof Pet)
        counter.count("Pet");
      if(pet instanceof Dog)
        counter.count("Dog");
      if(pet instanceof Mutt)
        counter.count("Mutt");
      if(pet instanceof Pug)
        counter.count("Pug");
      if(pet instanceof Cat)
        counter.count("Cat");
      if(pet instanceof Manx)
        counter.count("EgyptianMau");
      if(pet instanceof Manx)
        counter.count("Manx");
      if(pet instanceof Manx)
        counter.count("Cymric");
      if(pet instanceof Rodent)
        counter.count("Rodent");
      if(pet instanceof Rat)
        counter.count("Rat");
      if(pet instanceof Mouse)
        counter.count("Mouse");
      if(pet instanceof Hamster)
        counter.count("Hamster");
    }
    // Show the counts:
    System.out.println();
    System.out.println(counter);
  }    
  public static void main(String[] args) {
    countPets(new ForNameCreator());
  }
} /* Output:
Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric
{Pug=3, Cat=9, Hamster=1, Cymric=7, Mouse=2, Mutt=3, Rodent=5, Pet=20, Manx=7, EgyptianMau=7, Dog=6, Rat=2}
*///:~

 

　　对instanceof有比较严格的限制，只可将其与命名类型进行比较，而不能与Class对象作比较。

　　使用类字面常量

　　使用类字面常量重新实现PetCount。

public class LiteralPetCreator extends PetCreator {
  // No try block needed.
  @SuppressWarnings("unchecked")
  public static final List<Class<? extends Pet>> allTypes =
    Collections.unmodifiableList(Arrays.asList(
      Pet.class, Dog.class, Cat.class,  Rodent.class,
      Mutt.class, Pug.class, EgyptianMau.class, Manx.class,
      Cymric.class, Rat.class, Mouse.class,Hamster.class));
  // Types for random creation:
  private static final List<Class<? extends Pet>> types =
    allTypes.subList(allTypes.indexOf(Mutt.class),
      allTypes.size());
  public List<Class<? extends Pet>> types() {
    return types;
  }    
  public static void main(String[] args) {
    System.out.println(types);
  }
} /* Output:
[class typeinfo.pets.Mutt, class typeinfo.pets.Pug, class typeinfo.pets.EgyptianMau, class typeinfo.pets.Manx, class typeinfo.pets.Cymric, class typeinfo.pets.Rat, class typeinfo.pets.Mouse, class typeinfo.pets.Hamster]
*///:~

　　动态的instanceof

　　Class.isInstance方法提供了一种动态地测试对象的途径。

public class PetCount3 {
  static class PetCounter
  extends LinkedHashMap<Class<? extends Pet>,Integer> {
    public PetCounter() {
      super(MapData.map(LiteralPetCreator.allTypes, 0));
    }
    public void count(Pet pet) {
      // Class.isInstance() eliminates instanceofs:
      for(Map.Entry<Class<? extends Pet>,Integer> pair
          : entrySet())
        if(pair.getKey().isInstance(pet))
          put(pair.getKey(), pair.getValue() + 1);
    }    
    public String toString() {
      StringBuilder result = new StringBuilder("{");
      for(Map.Entry<Class<? extends Pet>,Integer> pair
          : entrySet()) {
        result.append(pair.getKey().getSimpleName());
        result.append("=");
        result.append(pair.getValue());
        result.append(", ");
      }
      result.delete(result.length()-2, result.length());
      result.append("}");
      return result.toString();
    }
  }    
  public static void main(String[] args) {
    PetCounter petCount = new PetCounter();
    for(Pet pet : Pets.createArray(20)) {
      printnb(pet.getClass().getSimpleName() + " ");
      petCount.count(pet);
    }
    print();
    print(petCount);
  }
} /* Output:
Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric
{Pet=20, Dog=6, Cat=9, Rodent=5, Mutt=3, Pug=3, EgyptianMau=2, Manx=7, Cymric=5, Rat=2, Mouse=2, Hamster=1}
*///:~

　　可以看到，isInstance()方法使我们不再需要instanceof表达式。此外，这意味着如果要求添加新类型的Pet，只需简单地改变LiteralPetCreator数组即可，而无需改动程序其他部分。

　　instanceof与Class的等价性

class Base {}
class Derived extends Base {}    

public class FamilyVsExactType {
  static void test(Object x) {
    System.out.println("Testing x of type " + x.getClass());
    System.out.println("x instanceof Base " + (x instanceof Base));
    System.out.println("x instanceof Derived " + (x instanceof Derived));
    System.out.println("Base.isInstance(x) " + Base.class.isInstance(x));
    System.out.println("Derived.isInstance(x) " +
            Derived.class.isInstance(x));
    System.out.println("x.getClass() == Base.class " +
            (x.getClass() == Base.class));
    System.out.println("x.getClass() == Derived.class " +
            (x.getClass() == Derived.class));
    System.out.println("x.getClass().equals(Base.class)) " +
            (x.getClass().equals(Base.class)));
    System.out.println("x.getClass().equals(Derived.class)) " +
            (x.getClass().equals(Derived.class)));
  }
  public static void main(String[] args) {
    test(new Base());
    test(new Derived());
  }    
} /* Output:
Testing x of type class typeinfo.Base
x instanceof Base true
x instanceof Derived false
Base.isInstance(x) true
Derived.isInstance(x) false
x.getClass() == Base.class true
x.getClass() == Derived.class false
x.getClass().equals(Base.class)) true
x.getClass().equals(Derived.class)) false
Testing x of type class typeinfo.Derived
x instanceof Base true
x instanceof Derived true
Base.isInstance(x) true
Derived.isInstance(x) true
x.getClass() == Base.class false
x.getClass() == Derived.class true
x.getClass().equals(Base.class)) false
x.getClass().equals(Derived.class)) true
*///:~

　　test()方法使用了两种形式的instanceof作为参数来执行类型检查。然后获取Class引用，并用==和equals()来检查Class对象是否相等。使人放心的是，instanceof和isInstance()生成的结果完全一样，equals()和==也一样。但是这两组测试得出的结论却不相同。instanceof保持了类型的概念，它指的是“你是这个类吗，或者你是这个类的派生类吗？”而如果用==比较实际的Class对象，就没有考虑继承--它或者是这个确切类型，或者不是。

　　反射：运行时类型信息

　　如果不知道某个对象的确切类型，RTTI可以告诉你。但是有一个限制：这个类型在编译时必须已知，这样才能使用RTTI识别它，并利用这些有用的信息做一些有用的事。换句话说，在编译时，编译器必须知道所有要通过RTTI来处理的类。
初看起来这似乎不是一个限制，但是假设你获取了一个指向某个并不在你的程序空间中的对象的引用；事实上，在编译时你的程序根本没法获知这个对象所属的类。例如，假设你从磁盘文件，或者网络连接中获取了一串字节，并且你被
告知这串字节代表一个类。既然这个类在编译器为你的程序生成代码之后很久才会出现，那么怎样才能使用这样的类呢？
　　在传统的编程环境中不太可能出现这种情况。但是当我们置身于更大规模的编程世界中，在许多重要情况下就会发生上面的事情。首先就是“基于构建的编程”，在此种编程方式中，将使用基于快速应用开发（RAD）的应用构建工具，即
集成开发环境（IDE）来构项目。这是一种可视化编程方法，可以通过将代表不同组件的图标拖拽到表单中来创建程序。然后在编程时通过设置构建的属性值来配置它们。这种设计时的配置，要求构建都是可实例化的，并且要暴露其部分信息，
以允许程序员读取和修改构建的属性。此外处理图形化界面（GUI）事件的构建还必须暴露相关方法的信息，以便IDE能够帮助程序员覆盖这些处理事件的方法。反射提供了一种机制，用来检查可用的方法，并返回方法名。
人们想要在运行时获取类的信息的另一个动机，便是希望提供在跨网络的远程平台上创建和运行对象的能力。这被称为远程方法调用（RMI），它允许一个Java程序将对象分布到多态机器上。需要这种分布能力是有许多原因的。例如，
你可能正在进行一项需进行大量计算的任务，为了提高运算速度，想将计算划分为许多小的计算单元，分布到空闲的机器上运行。
　　Class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含了Field、Method以及Constructor类。这些类型的对象是由JVM在运行时创建的，用以表示未知类里对应的成员。这样你就可以使用Construcotr创建新的对象，
用get()和set()方法读取和修改与Field对象关联的字段，用invoke()方法调用与Method对相关联的方法。另外，还可以调用getFields()、getMethod()和getConstructors()等很便利的方法，以返回表示字段，方法以及构造器的对象的数组。
这样，匿名对象的类信息就能在运行时被完全确定下来，而在编译时不需要知道任何事情。
　　重要的是，要认识到反射机制并没有什么神奇之处。当通过反射与一个未知类型的对象打交道时，JVM只是简单的检查这个对象，看它属于哪个特定的类。在用它做其他事情之前必须先加载那个类的Class对象。因此，那个类的.class文件对于
JVM来说必须是可获取的，要么在本地机器上，要么在远程网络上。所以RTTI和反射之间真正的区别只在于：对RTTI来说，编译器在编译时打开和检查.class文件。（换句话说，我们可以用普通方式调用对象的所有方法。）而对于反射机制来说，
.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。

　　类方法提取器

　　通常你不需要直接使用反射工具，但是它们在你需要创建更加动态的代码时会很有用。反射在java中是用来支持其他特性的，例如对象序列化和JavaBean。但是，如果能动态地提取某个类的信息有的时候还是很有用的，请考虑类方法提取器。反射机制提供了一种方法，使我们能够编写可以自动展示完整接口的简单工具。下面是其工作方式

public class ShowMethods {
  private static String usage =
    "usage:\n" +
    "ShowMethods qualified.class.name\n" +
    "To show all methods in class or:\n" +
    "ShowMethods qualified.class.name word\n" +
    "To search for methods involving 'word'";
  private static Pattern p = Pattern.compile("\\w+\\.");
  public static void main(String[] args) {
    if(args.length < 1) {
      System.out.println(usage);
      System.exit(0);
    }
    int lines = 0;
    try {
      Class<?> c = Class.forName(args[0]);
      Method[] methods = c.getMethods();
      Constructor[] ctors = c.getConstructors();
      if(args.length == 1) {
        for(Method method : methods)
          System.out.println(
                  p.matcher(method.toString()).replaceAll(""));
        for(Constructor ctor : ctors)
          System.out.println(p.matcher(ctor.toString()).replaceAll(""));
        lines = methods.length + ctors.length;
      } else {
        for(Method method : methods)
          if(method.toString().indexOf(args[1]) != -1) {
            System.out.println(
                    p.matcher(method.toString()).replaceAll(""));
            lines++;
          }
        for(Constructor ctor : ctors)
          if(ctor.toString().indexOf(args[1]) != -1) {
            System.out.println(p.matcher(
                    ctor.toString()).replaceAll(""));
            lines++;
          }
      }
    } catch(ClassNotFoundException e) {
      System.out.println("No such class: " + e);
    }
  }
} /* Output:
public static void main(String[])
public native int hashCode()
public final native Class getClass()
public final void wait(long,int) throws InterruptedException
public final void wait() throws InterruptedException
public final native void wait(long) throws InterruptedException
public boolean equals(Object)
public String toString()
public final native void notify()
public final native void notifyAll()
public ShowMethods()
*///:~

　　动态代理

 　  代理是基本的设计模式之一，它是你为了提供额外的或不同的操作，而插入的用来代替实际对象的对象。这些操作通常涉及与实际对象的通信，因此代理通常充当中间人的角色。

interface Interface {
  void doSomething();
  void somethingElse(String arg);
}

class RealObject implements Interface {
  public void doSomething() { System.out.println("doSomething"); }
  public void somethingElse(String arg) {
    System.out.println("somethingElse " + arg);
  }
}    

class SimpleProxy implements Interface {
  private Interface proxied;
  public SimpleProxy(Interface proxied) {
    this.proxied = proxied;
  }
  public void doSomething() {
    System.out.println("SimpleProxy doSomething");
    proxied.doSomething();
  }
  public void somethingElse(String arg) {
    System.out.println("SimpleProxy somethingElse " + arg);
    proxied.somethingElse(arg);
  }
}    

class SimpleProxyDemo {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    consumer(new RealObject());
    consumer(new SimpleProxy(new RealObject()));
  }
} /* Output:
doSomething
somethingElse bonobo
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse bonobo
somethingElse bonobo
*///:~

　　Java动态代理比代理思想更进一步，因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理商所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的对策。

class DynamicProxyHandler implements InvocationHandler {
  private Object proxied;
  public DynamicProxyHandler(Object proxied) {
    this.proxied = proxied;
  }
  public Object
  invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
    System.out.println("**** proxy: " + proxy.getClass() +
      ", method: " + method + ", args: " + args);
    if(args != null)
      for(Object arg : args)
        System.out.println("  " + arg);
    return method.invoke(proxied, args);
  }
}    

class SimpleDynamicProxy {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    RealObject real = new RealObject();
    consumer(real);
    // Insert a proxy and call again:
    Interface proxy = (Interface)Proxy.newProxyInstance(
      Interface.class.getClassLoader(),
      new Class[]{ Interface.class },
      new DynamicProxyHandler(real));
    consumer(proxy);
  }
} /* Output: (95% match)    
doSomething
somethingElse bonobo
**** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null
doSomething
**** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@42e816
  bonobo
somethingElse bonobo
*///:~

　　空对象

　　当你使用内置的null表示缺少对象时，在每次使用引用时都必须测试其是否为null，这显得枯燥，而且势必产生相当乏味的代码。问题在于null除了在你试图用它执行任何操作来产生NullPointerException之外，它自己没有其他任何行为。有时引入空对象的思想将会很有用，它可以接受传递给它的所代表的对象的消息，但是将返回表示为实际上并不存在任何“真实”对象的值。通过这种方式，你可以假设所有的对象都是有效的，而不必浪费精力去检查null。

　　尽管想象一种可以自动为我们创建空对象的编程语言显得很有趣，但是实际上，到处使用空对象并没有任何意义，有时检查null就可以了，有时你可以合理地假设你根本不会遇到null，有时甚至通过NullPointerException来探测异常也可以接受的，空对象最有用之处在于它更靠近数据，因为对象表示的问题空间内的实体。有一个简单的例子，许多系统都有一个Person类，而在代码中，有很多情况是你没有一个实际的人。因此，通常你会用一个null引用并测试它。与此不同的是，我们可以使用空对象。但是即使空对象可以相应“实际”对象可以相应的所有消息，你仍需要某种方式去测试其是否为空。要达到此目的，最简单的方式是创建一个标记接口：

　　 public interface Null {} ///:~ 

　　这使得instanceof可以探测空对象，更重要的是，这并不要求你所有的类中添加isNull()方法。

class Person {
  public final String first;
  public final String last;
  public final String address;
  // etc.
  public Person(String first, String last, String address){
    this.first = first;
    this.last = last;
    this.address = address;
  }    
  public String toString() {
    return "Person: " + first + " " + last + " " + address;
  }
  public static class NullPerson
  extends Person implements Null {
    private NullPerson() { super("None", "None", "None"); }
    public String toString() { return "NullPerson"; }
  }
  public static final Person NULL = new NullPerson();
} ///:~

　　现在假设你回到了互联网刚出现的雄心万丈的年代，并且你已经因你惊人的理念而获得了一大笔风险投资。你现在要招兵买马了，但是在虚位以待时，你可以将person空对象放在每个Position上

class Position {
  private String title;
  private Person person;
  public Position(String jobTitle, Person employee) {
    title = jobTitle;
    person = employee;
    if(person == null)
      person = Person.NULL;
  }
  public Position(String jobTitle) {
    title = jobTitle;
    person = Person.NULL;
  }    
  public String getTitle() { return title; }
  public void setTitle(String newTitle) {
    title = newTitle;
  }
  public Person getPerson() { return person; }
  public void setPerson(Person newPerson) {
    person = newPerson;
    if(person == null)
      person = Person.NULL;
  }
  public String toString() {
    return "Position: " + title + " " + person;
  }
} ///:~

　　如果你用接口取代具体类，那么就可以使用DynamicProxy来自动地创建空对象。假设我们有一个Robot接口，它定义了一个名字、一个模型和一个描述Robot行为能力的List<Operation>.Operation包含一个描述和一个命令。

public interface Operation {
  String description();
  void command();
} ///:~
public interface Robot {
  String name();
  String model();
  List<Operation> operations();
  class Test {
    public static void test(Robot r) {
      if(r instanceof Null)
        System.out.println("[Null Robot]");
      System.out.println("Robot name: " + r.name());
      System.out.println("Robot model: " + r.model());
      for(Operation operation : r.operations()) {
        System.out.println(operation.description());
        operation.command();
      }
    }
  }
} ///:~
public class SnowRemovalRobot implements Robot {
  private String name;
  public SnowRemovalRobot(String name) {this.name = name;}
  public String name() { return name; }
  public String model() { return "SnowBot Series 11"; }
  public List<Operation> operations() {
    return Arrays.asList(
      new Operation() {
        public String description() {
          return name + " can shovel snow";
        }
        public void command() {
          System.out.println(name + " shoveling snow");
        }
      },    
      new Operation() {
        public String description() {
          return name + " can chip ice";
        }
        public void command() {
          System.out.println(name + " chipping ice");
        }
      },
      new Operation() {
        public String description() {
          return name + " can clear the roof";
        }
        public void command() {
          System.out.println(name + " clearing roof");
        }
      }
    );
  }    
  public static void main(String[] args) {
    Robot.Test.test(new SnowRemovalRobot("Slusher"));
  }
} /* Output:
Robot name: Slusher
Robot model: SnowBot Series 11
Slusher can shovel snow
Slusher shoveling snow
Slusher can chip ice
Slusher chipping ice
Slusher can clear the roof
Slusher clearing roof
*///:~

　　假设存在许多不同类型的Robot，我们想对每一种Robot类型都创建一个空对象，去执行某些特殊操作--在本例中，即提供空对象所代表的Robot确切类型的信息。这些信息是通过动态代理捕获的。

class NullRobotProxyHandler implements InvocationHandler {
  private String nullName;
  private Robot proxied = new NRobot();
  NullRobotProxyHandler(Class<? extends Robot> type) {
    nullName = type.getSimpleName() + " NullRobot";
  }
  private class NRobot implements Null, Robot {
    public String name() { return nullName; }
    public String model() { return nullName; }
    public List<Operation> operations() {
      return Collections.emptyList();
    }
  }    
  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(type));
  }    
  public static void main(String[] args) {
    Robot[] bots = {
      new SnowRemovalRobot("SnowBee"),
      newNullRobot(SnowRemovalRobot.class)
    };
    for(Robot bot : bots)
      Robot.Test.test(bot);
  }
} /* Output:
Robot name: SnowBee
Robot model: SnowBot Series 11
SnowBee can shovel snow
SnowBee shoveling snow
SnowBee can chip ice
SnowBee chipping ice
SnowBee can clear the roof
SnowBee clearing roof
[Null Robot]
Robot name: SnowRemovalRobot NullRobot
Robot model: SnowRemovalRobot NullRobot
*///:~

　　无论何时，如果你需要一个空Robot对象，只需要调用newNullRobot()，并传递需要代理的Robot的类型。代理会满足Robot和Null接口的需求，并提供它所代理的类型的确切名字。

　　接口与类型信息

　　interface关键字的一个重要目标就是允许程序员隔离构件、进而降低耦合性。如果你编写接口，那么就可以实现这一目标，但是通过类型信息，这种耦合性还是会传播出去--接口并非是对解耦的一种无懈可击的保障。

 public interface A { 2 void f(); 3 } ///:~ 

　　然后实现这个接口，你可以看到其代码是如何围绕着实际的实现类型潜行的

class B implements A {
  public void f() {}
  public void g() {}
}

public class InterfaceViolation {
  public static void main(String[] args) {
    A a = new B();
    a.f();
    // a.g(); // Compile error
    System.out.println(a.getClass().getName());
    if(a instanceof B) {
      B b = (B)a;
      b.g();
    }
  }
} /* Output:
B
*///:~

　　通过使用RTTI，我们发现a是被当做B实现的。通过将其转型为B，我们可以调用不在A中的方法。

　　这是完全合法和可接受的，但是你也许并不像让客户端程序员这么做，因为这给了他们一个机会，使得他们的代码与你的代码的耦合度超过你的期望。也就是说，你可能认为interface关键字正在保护你，但是它并没有。

　　一种解决方案是直接声明，如果程序员决定使用实际的类而不是接口，他们需要自己对自己负责。这在很多情况下可能都是合理地，但“可能”还不够，你也许希望应用一些更严苛的控制。

　　最简单的方式是使用包访问权限

class C implements A {
  public void f() {
    System.out.println("public C.f()"); }
  public void g() { System.out.println("public C.g()"); }
  void u() { System.out.println("package C.u()"); }
  protected void v() { System.out.println("protected C.v()"); }
  private void w() { System.out.println("private C.w()"); }
}

public class HiddenC {
  public static A makeA() { return new C(); }
} ///:~

　　如果你试图将其向下转型为C，则将被禁止。

public class HiddenImplementation {
  public static void main(String[] args) throws Exception {
    A a = HiddenC.makeA();
    a.f();
    System.out.println(a.getClass().getName());
    // Compile error: cannot find symbol 'C':
    /* if(a instanceof C) {
      C c = (C)a;
      c.g();
    } */
    // Oops! Reflection still allows us to call g():
    callHiddenMethod(a, "g");
    // And even methods that are less accessible!
    callHiddenMethod(a, "u");
    callHiddenMethod(a, "v");
    callHiddenMethod(a, "w");
  }
  static void callHiddenMethod(Object a, String methodName)
  throws Exception {
    Method g = a.getClass().getDeclaredMethod(methodName);
    g.setAccessible(true);
    g.invoke(a);
  }
} /* Output:
public C.f()
typeinfo.packageaccess.C
public C.g()
package C.u()
protected C.v()
private C.w()
*///:~

　　正如你看到的，通过使用反射，仍旧可以到达并调用所有方法，甚至是private方法！如果知道方法名，你就可以在Method对象上调用setAccessible(true),就像在callHiddenMethod()中看到的那样。

　　我们看看私有内部类是什么情况？

class InnerA {
  private static class C implements A {
    public void f() {
      System.out.println("public C.f()"); }
    public void g() { System.out.println("public C.g()"); }
    void u() { System.out.println("package C.u()"); }
    protected void v() { System.out.println("protected C.v()"); }
    private void w() { System.out.println("private C.w()"); }
  }
  public static A makeA() { return new C(); }
}    

public class InnerImplementation {
  public static void main(String[] args) throws Exception {
    A a = InnerA.makeA();
    a.f();
    System.out.println(a.getClass().getName());
    // Reflection still gets into the private class:
    HiddenImplementation.callHiddenMethod(a, "g");
    HiddenImplementation.callHiddenMethod(a, "u");
    HiddenImplementation.callHiddenMethod(a, "v");
    HiddenImplementation.callHiddenMethod(a, "w");
  }
} /* Output:
public C.f()
InnerA$C
public C.g()
package C.u()
protected C.v()
private C.w()
*///:~

　　看来，反射一样免疫。

　　再看看匿名类

class AnonymousA {
  public static A makeA() {
    return new A() {
      public void f() {
        System.out.println("public C.f()"); }
      public void g() { System.out.println("public C.g()"); }
      void u() { System.out.println("package C.u()"); }
      protected void v() { System.out.println("protected C.v()"); }
      private void w() { System.out.println("private C.w()"); }
    };
  }
}    

public class AnonymousImplementation {
  public static void main(String[] args) throws Exception {
    A a = AnonymousA.makeA();
    a.f();
    System.out.println(a.getClass().getName());
    // Reflection still gets into the anonymous class:
    HiddenImplementation.callHiddenMethod(a, "g");
    HiddenImplementation.callHiddenMethod(a, "u");
    HiddenImplementation.callHiddenMethod(a, "v");
    HiddenImplementation.callHiddenMethod(a, "w");
  }
} /* Output:
public C.f()
AnonymousA$1
public C.g()
package C.u()
protected C.v()
private C.w()
*///:~

　　一样免疫。

　　看起来没有任何方式可以阻止反射到达并调用那些非公共访问权限的方法。对于域来说，的确如此，即便是private域。

class WithPrivateFinalField {
  private int i = 1;
  private final String s = "I'm totally safe";
  private String s2 = "Am I safe?";
  public String toString() {
    return "i = " + i + ", " + s + ", " + s2;
  }
}

public class ModifyingPrivateFields {
  public static void main(String[] args) throws Exception {
    WithPrivateFinalField pf = new WithPrivateFinalField();
    System.out.println(pf);
    Field f = pf.getClass().getDeclaredField("i");
    f.setAccessible(true);
    System.out.println("f.getInt(pf): " + f.getInt(pf));
    f.setInt(pf, 47);
    System.out.println(pf);
    f = pf.getClass().getDeclaredField("s");
    f.setAccessible(true);
    System.out.println("f.get(pf): " + f.get(pf));
    f.set(pf, "No, you're not!");
    System.out.println(pf);
    f = pf.getClass().getDeclaredField("s2");
    f.setAccessible(true);
    System.out.println("f.get(pf): " + f.get(pf));
    f.set(pf, "No, you're not!");
    System.out.println(pf);
  }
} /* Output:
i = 1, I'm totally safe, Am I safe?
f.getInt(pf): 1
i = 47, I'm totally safe, Am I safe?
f.get(pf): I'm totally safe
i = 47, I'm totally safe, Am I safe?
f.get(pf): Am I safe?
i = 47, I'm totally safe, No, you're not!
*///:~