Java集合的缺点：类型未知

核心提示：使用java集合的“缺点”是在将对象置入一个集合时丢失了类型信息，之所以会发生这种情况，Java集合的缺点：类型未知，是由于当初编写集合时，那个集合的程序员根本不知道用户到底想把什么类型置入集合，为了让自己类的对象能显示出来，要做的全部事情就是覆盖toString()方法，若指示某个集合只答应特定的类型，会妨碍它成为一

　　使用java集合的“缺点”是在将对象置入一个集合时丢失了类型信息。之所以会发生这种情况，是由于当初编写集合时，那个集合的程序员根本不知道用户到底想把什么类型置入集合。若指示某个集合只答应特定的类型，会妨碍它成为一个“常规用途”的工具，为用户带来麻烦。为解决这个问题，集合实际容纳的是类型为Object的一些对象的句柄。这种类型当然代表Java中的所有对象，因为它是所有类的根。当然，也要注重这并不包括基本数据类型，因为它们并不是从“任何东西”继续来的。这是一个很好的方案，只是不适用下述场合：
　　(1) 将一个对象句柄置入集合时，由于类型信息会被抛弃，所以任何类型的对象都可进入我们的集合——即便非凡指示它只能容纳特定类型的对象。举个例子来说，虽然指示它只能容纳猫，但事实上任何人都可以把一条狗扔进来。
　　(2) 由于类型信息不复存在，所以集合能肯定的唯一事情就是自己容纳的是指向一个对象的句柄。正式使用它之前，必须对其进行造型，使其具有正确的类型。
　　
　　值得欣慰的是，Java不答应人们滥用置入集合的对象。假如将一条狗扔进一个猫的集合，那么仍会将集合内的所有东西都看作猫，所以在使用那条狗时会得到一个“违例”错误。在同样的意义上，假若试图将一条狗的句柄“造型”到一只猫，那么运行期间仍会得到一个“违例”错误。
　　下面是个例子：
　　
　　//: CatsAndDogs.java
　　// Simple collection example (Vector)
　　import java.util.*;
　　
　　class Cat {
　　　PRivate int catNumber;
　　　Cat(int i) {
　　　　catNumber = i;
　　　}
　　　void print() {
　　　　System.out.println("Cat #" + catNumber);
　　　}
　　}
　　
　　class Dog {
　　　private int dogNumber;
　　　Dog(int i) {
　　　　dogNumber = i;
　　　}
　　　void print() {
　　　　System.out.println("Dog #" + dogNumber);
　　　}
　　}
　　
　　public class CatsAndDogs {
　　　public static void main(String[] args) {
　　　　Vector cats = new Vector();
　　　　for(int i = 0; i < 7; i++)
　　　　　cats.addElement(new Cat(i));
　　　　// Not a problem to add a dog to cats:
　　　　cats.addElement(new Dog(7));
　　　　for(int i = 0; i < cats.size(); i++)
　　　　　((Cat)cats.elementAt(i)).print();
　　　　// Dog is detected only at run-time
　　　}
　　} ///:~
　　
　　可以看出，Vector的使用是非常简单的：先创建一个，再用addElement()置入对象，以后用elementAt()取得那些对象（注重Vector有一个size()方法，可使我们知道已添加了多少个元素，以便防止误超边界，造成违例错误）。
　　Cat和Dog类都非常浅显——除了都是“对象”之外，它们并无非凡之处（倘若不明确指出从什么类继续，就默认为从Object继续。所以我们不仅能用Vector方法将Cat对象置入这个集合，也能添加Dog对象，同时不会在编译期和运行期得到任何出错提示。用Vector方法elementAt()获取原本认为是Cat的对象时，实际获得的是指向一个Object的句柄，必须将那个对象造型为Cat。随后，需要将整个表达式用括号封闭起来，在为Cat调用print()方法之前进行强制造型；否则就会出现一个语法错误。在运行期间，假如试图将Dog对象造型为Cat，就会得到一个违例。
　　这些处理的意义都非常深远。尽管显得有些麻烦，但却获得了安全上的保证。我们从此再难偶然造成一些隐藏得深的错误。若程序的一个部分（或几个部分）将对象插入一个集合，但我们只是通过一次违例在程序的某个部分发现一个错误的对象置入了集合，就必须找出插入错误的位置。当然，可通过检查代码达到这个目的，但这或许是最笨的调试工具。另一方面，我们可从一些标准化的集合类开始自己的编程。尽管它们在功能上存在一些不足，且显得有些笨拙，但却能保证没有隐藏的错误。
　　
　　1. 错误有时并不显露出来
　　
　　在某些情况下，程序似乎正确地工作，不造型回我们原来的类型。第一种情况是相当非凡的：String类从编译器获得了额外的帮助，使其能够正常工作。只要编译器期待的是一个String对象，但它没有得到一个，就会自动调用在Object里定义、并且能够由任何Java类覆盖的toString()方法。这个方法能生成满足要求的String对象，然后在我们需要的时候使用。
　　因此，为了让自己类的对象能显示出来，要做的全部事情就是覆盖toString()方法，如下例所示：
　　
　　//: WorksAnyway.java
　　// In special cases, things just seem
　　// to work correctly.
　　import java.util.*;
　　
　　class Mouse {
　　　private int mouseNumber;
　　　Mouse(int i) {
　　　　mouseNumber = i;
　　　}
　　　// Magic method:
　　　public String toString() {
　　　　return "This is Mouse #" + mouseNumber;
　　　}
　　　void print(String msg) {
　　　　if(msg != null) System.out.println(msg);
　　　　System.out.println(
　　　　　"Mouse number " + mouseNumber);
　　　}
　　}
　　
　　class MouseTrap {
　　　static void caughtYa(Object m) {
　　　　Mouse mouse = (Mouse)m; // Cast from Object
　　　　mouse.print("Caught one!");
　　　}
　　}
　　
　　public class WorksAnyway {
　　　public static void main(String[] args) {
　　　　Vector mice = new Vector();
　　　　for(int i = 0; i < 3; i++)
　　　　　mice.addElement(new Mouse(i));
　　　　for(int i = 0; i < mice.size(); i++) {
　　　　　// No cast necessary, automatic call
　　　　　// to Object.toString():
　　　　　System.out.println(
　　　　　　"Free mouse: " + mice.elementAt(i));
　　　　　MouseTrap.caughtYa(mice.elementAt(i));
　　　　}
　　　}
　　} ///:~
　　
　　可在Mouse里看到对toString()的重定义代码。