Picses' sky

[译者按：]

Bruce Eckel在前不久写了一片批判Java的泛型的文章，结合他在OO上浸淫多年的功力，一眼就看出了Java的泛型和其他例如C++，Python，Ruby等等这些语言的泛型的差别。

不过平心而论，Bruce Eckel的批评是比较中肯的，因为他也看到了Java和其他这些面向对象的语言之间的差别，他也可以理解Java实现出了这样的泛型。

另外，如果大家不知道Ruby是什么，可以参考下面的网站：http://www.ruby-lang.org/en/

[补充]添加一段Bruce Eckel自己的评论：

Guess what. I really don't care. You want to call it "generics," fine, implement something that looks like C++ or Ada, that actually produces a latent typing mechanism like they do. But don't implement something whose sole purpose is to solve the casting problem in containers, and then insist that on calling it "Generics." Of course, Java has long precedence in arrogantly mangling well- accepted meanings for things: one that particularly stuck in my craw was the use of "design pattern" to describe getters and setters. In JDK 1.4 we were told some lame way to use assertions which was a backward justification for them being disabled by default. JDK 1.4 also had to invent its own inferior logging system rather than using the openly created, well-tested and well-liked Log4J. And we've also been told many times about how Java has been as fast or faster than C++, or about how one or another feature is great and flawless. I point to the threads implementation which has had major changes quietly made from version to version with not so much as a peep of apology or admission that "hey, we really screwed up here." Or maybe I was just not on that particular announcement list.

昨晚，我作为嘉宾被Silicon Valley的模式组邀请去参加他们的一个研讨会，并且让我来决定讨论的主题，为了更好的了解JDK1.5，我选择了Java的Generics（泛型），最后讨论的结果是我们大家都有点震惊。我们讨论的主要素材是最新的Sun推出的Java 泛型手册。我对“参数化类型”的经验来自于C++，而C++的泛型又是基于ADA的Generics，事实上，Lisp语言是第一个实现了泛型的语言，有人说Simula语言也很早就有泛型了。在这些语言中，当你使用参数化的类型的时候，这个参数是作为一种隐式类型（latent type）的：一种被实现出了如何使用，但是却没有显式的声明的类型。也就是说，隐式类型是一种通过你调用方法来实现的。例如，你的模板方法是某个类型中的f()和g()，那么接下来你实现了一个类型包含了f()和g()这两个方法，而事实上这个类型可能从来被定义过。举个例子，在Python中，你可以这样做：

def speak(anything):
    anything.talk()

class Dog:
    def talk(self):  print "Arf!"
    def reproduce(self): pass

class Robot:
    def talk(self): print "Click!"
    def oilChange(self): pass

a = Dog()
b = Robot()
speak(a)
speak(b)

class Dog {
public:
  void talk() { }
  void reproduce() { }
};

class Robot {
public:
  void talk() { }
  void oilChange() { }
};

template void speak(T speaker) {
  speaker.talk();
}

int main() {
  Dog d;
  Robot r;
  speak(d);
  speak(r);
}

public class Communicate  {
  public  void speak(T speaker) {
    speaker.talk();
  }
}

public class Communicate  {
  public  void speak(T speaker) {
    speaker.toString(); // Object methods work!
  }
}

interface Speaks { void speak(); }

public class Communicate  {
  public  void speak(T speaker) {
    speaker.speak();
  }
}

interface Speaks { void speak(); }

public class CommunicateSimply  {
  public void speak(Speaks speaker) {
    speaker.speak();
  }
}

interface Speaks { void talk(); }

class Dog implements Speaks {
  public void talk() { }
  public void reproduce() { }
}

class Robot implements Speaks {
  public void talk() { }
  public void oilChange() { }
}

class Communicate {
  public static  void speak(T speaker) {
    speaker.talk();
  }
}

public class DogsAndRobots {
  public static void main(String[] args) {
    Dog d = new Dog();
    Robot r = new Robot();
    Communicate.speak(d);
    Communicate.speak(r);
  }
}

interface Speaks { void talk(); }

class Dog implements Speaks {
  public void talk() { }
  public void reproduce() { }
}

class Robot implements Speaks {
  public void talk() { }
  public void oilChange() { }
}

class Communicate {
  public static void speak(Speaks speaker) {
    speaker.talk();
  }
}

public class SimpleDogsAndRobots {
  public static void main(String[] args) {
    Dog d = new Dog();
    Robot r = new Robot();
    Communicate.speak(d);
    Communicate.speak(r);
  }
}